### `getTrimmed() → ViewRange`
Creates a minimum range that has the same content as this range but is trimmed in both ways (at the beginning and at the end).
For example:
```html
Foo
[Bar]
-> Foo
{Bar}
foo[bar]
-> foo{bar}
```
Note that in the sample above:
* `` have type of [`ViewContainerElement`](module_engine_view_containerelement-ViewContainerElement.md),
* `` have type of [`ViewAttributeElement`](module_engine_view_attributeelement-ViewAttributeElement.md),
* `` have type of [`ViewUIElement`](module_engine_view_uielement-ViewUIElement.md).
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L146)
#### Returns
* `ViewRange`
Shrunk range.
### `getWalker( options ) → ViewTreeWalker`
Creates a [TreeWalker](module_engine_view_treewalker-ViewTreeWalker.md) instance with this range as a boundary.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L323)
#### Parameters
* `options: ViewTreeWalkerOptions`
Object with configuration options. See [`ViewTreeWalker`](module_engine_view_treewalker-ViewTreeWalker.md).
Defaults to `{}`
#### Returns
* `ViewTreeWalker`
### `is( type ) → this is ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` _(inherited)_
Checks whether this object is of type [`ViewElement`](module_engine_view_element-ViewElement.md) or its subclass.
```typescript
element.is( 'element' ); // -> true
element.is( 'node' ); // -> true
element.is( 'view:element' ); // -> true
element.is( 'view:node' ); // -> true
element.is( 'model:element' ); // -> false
element.is( 'documentSelection' ); // -> false
```
Assuming that the object being checked is an element, you can also check its [name](module_engine_view_element-ViewElement.md#member-name):
```typescript
element.is( 'element', 'img' ); // -> true if this is an ![]()
element
text.is( 'element', 'img' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L93)
#### Parameters
* `type: 'element' | 'view:element'`
#### Returns
* `this is ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement`
### `is( type ) → this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement` _(inherited)_
Checks whether this object is of type [`ViewContainerElement`](module_engine_view_containerelement-ViewContainerElement.md) or its subclass.
```typescript
containerElement.is( 'containerElement' ); // -> true
containerElement.is( 'element' ); // -> true
containerElement.is( 'node' ); // -> true
containerElement.is( 'view:containerElement' ); // -> true
containerElement.is( 'view:element' ); // -> true
containerElement.is( 'view:node' ); // -> true
containerElement.is( 'model:element' ); // -> false
containerElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is a container element, you can also check its [name](module_engine_view_containerelement-ViewContainerElement.md#member-name):
```typescript
containerElement.is( 'element', 'div' ); // -> true if this is a div container element
containerElement.is( 'contaienrElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L158)
#### Parameters
* `type: 'containerElement' | 'view:containerElement'`
#### Returns
* `this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement`
### `is( type ) → this is ViewEditableElement | ViewRootEditableElement` _(inherited)_
Checks whether this object is of type [`ViewEditableElement`](module_engine_view_editableelement-ViewEditableElement.md) or its subclass.
```typescript
editableElement.is( 'editableElement' ); // -> true
editableElement.is( 'element' ); // -> true
editableElement.is( 'node' ); // -> true
editableElement.is( 'view:editableElement' ); // -> true
editableElement.is( 'view:element' ); // -> true
editableElement.is( 'view:node' ); // -> true
editableElement.is( 'model:element' ); // -> false
editableElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is an editbale element, you can also check its [name](module_engine_view_editableelement-ViewEditableElement.md#member-name):
```typescript
editableElement.is( 'element', 'div' ); // -> true if this is a div element
editableElement.is( 'editableElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L187)
#### Parameters
* `type: 'editableElement' | 'view:editableElement'`
#### Returns
* `this is ViewEditableElement | ViewRootEditableElement`
### `is( type ) → this is ViewAttributeElement` _(inherited)_
Checks whether this object is of type [`ViewAttributeElement`](module_engine_view_attributeelement-ViewAttributeElement.md).
```typescript
attributeElement.is( 'attributeElement' ); // -> true
attributeElement.is( 'element' ); // -> true
attributeElement.is( 'node' ); // -> true
attributeElement.is( 'view:attributeElement' ); // -> true
attributeElement.is( 'view:element' ); // -> true
attributeElement.is( 'view:node' ); // -> true
attributeElement.is( 'model:element' ); // -> false
attributeElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is an attribute element, you can also check its [name](module_engine_view_attributeelement-ViewAttributeElement.md#member-name):
```typescript
attributeElement.is( 'element', 'b' ); // -> true if this is a bold element
attributeElement.is( 'attributeElement', 'b' ); // -> same as above
text.is( 'element', 'b' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L130)
#### Parameters
* `type: 'attributeElement' | 'view:attributeElement'`
#### Returns
* `this is ViewAttributeElement`
### `is( type ) → this is ViewRootEditableElement` _(inherited)_
Checks whether this object is of type [`ViewRootEditableElement`](module_engine_view_rooteditableelement-ViewRootEditableElement.md).
```typescript
rootEditableElement.is( 'rootElement' ); // -> true
rootEditableElement.is( 'editableElement' ); // -> true
rootEditableElement.is( 'element' ); // -> true
rootEditableElement.is( 'node' ); // -> true
rootEditableElement.is( 'view:editableElement' ); // -> true
rootEditableElement.is( 'view:element' ); // -> true
rootEditableElement.is( 'view:node' ); // -> true
rootEditableElement.is( 'model:element' ); // -> false
rootEditableElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is a root editable element, you can also check its [name](module_engine_view_rooteditableelement-ViewRootEditableElement.md#member-name):
```typescript
rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element
rootEditableElement.is( 'rootElement', 'div' ); // -> same as above
text.is( 'element', 'div' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L272)
#### Parameters
* `type: 'rootElement' | 'view:rootElement'`
#### Returns
* `this is ViewRootEditableElement`
### `is( type ) → this is ViewTextProxy` _(inherited)_
Checks whether this object is of type [`ViewTextProxy`](module_engine_view_textproxy-ViewTextProxy.md).
```typescript
textProxy.is( '$textProxy' ); // -> true
textProxy.is( 'view:$textProxy' ); // -> true
textProxy.is( 'model:$textProxy' ); // -> false
textProxy.is( 'element' ); // -> false
textProxy.is( 'range' ); // -> false
```
**Note:** Until version 20.0.0 this method wasn't accepting `'$textProxy'` type. The legacy `'textProxy'` type is still accepted for backward compatibility.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L353)
#### Parameters
* `type: '$textProxy' | 'view:$textProxy'`
#### Returns
* `this is ViewTextProxy`
### `is( type ) → this is ViewPosition` _(inherited)_
Checks whether this object is of type [`ViewPosition`](module_engine_view_position-ViewPosition.md).
```typescript
position.is( 'position' ); // -> true
position.is( 'view:position' ); // -> true
position.is( 'model:position' ); // -> false
position.is( 'element' ); // -> false
position.is( 'range' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L369)
#### Parameters
* `type: 'position' | 'view:position'`
#### Returns
* `this is ViewPosition`
### `is( type ) → this is ViewDocumentFragment` _(inherited)_
hecks whether this object is of type [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md).
```typescript
docFrag.is( 'documentFragment' ); // -> true
docFrag.is( 'view:documentFragment' ); // -> true
docFrag.is( 'model:documentFragment' ); // -> false
docFrag.is( 'element' ); // -> false
docFrag.is( 'node' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L334)
#### Parameters
* `type: 'documentFragment' | 'view:documentFragment'`
#### Returns
* `this is ViewDocumentFragment`
### `is( type ) → this is ViewText` _(inherited)_
Checks whether this object is of type [`ViewText`](module_engine_view_text-ViewText.md).
```typescript
text.is( '$text' ); // -> true
text.is( 'node' ); // -> true
text.is( 'view:$text' ); // -> true
text.is( 'view:node' ); // -> true
text.is( 'model:$text' ); // -> false
text.is( 'element' ); // -> false
text.is( 'range' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L318)
#### Parameters
* `type: '$text' | 'view:$text'`
#### Returns
* `this is ViewText`
### `is( type ) → this is ViewUIElement` _(inherited)_
Checks whether this object is of type [`ViewUIElement`](module_engine_view_uielement-ViewUIElement.md).
```typescript
uiElement.is( 'uiElement' ); // -> true
uiElement.is( 'element' ); // -> true
uiElement.is( 'node' ); // -> true
uiElement.is( 'view:uiElement' ); // -> true
uiElement.is( 'view:element' ); // -> true
uiElement.is( 'view:node' ); // -> true
uiElement.is( 'model:element' ); // -> false
uiElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is an ui element, you can also check its [name](module_engine_view_uielement-ViewUIElement.md#member-name):
```typescript
uiElement.is( 'element', 'span' ); // -> true if this is a span ui element
uiElement.is( 'uiElement', 'span' ); // -> same as above
text.is( 'element', 'span' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L300)
#### Parameters
* `type: 'uiElement' | 'view:uiElement'`
#### Returns
* `this is ViewUIElement`
### `is( type ) → this is ViewRawElement` _(inherited)_
Checks whether this object is of type [`ViewRawElement`](module_engine_view_rawelement-ViewRawElement.md).
```typescript
rawElement.is( 'rawElement' ); // -> true
rawElement.is( 'element' ); // -> true
rawElement.is( 'node' ); // -> true
rawElement.is( 'view:rawElement' ); // -> true
rawElement.is( 'view:element' ); // -> true
rawElement.is( 'view:node' ); // -> true
rawElement.is( 'model:element' ); // -> false
rawElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is a raw element, you can also check its [name](module_engine_view_rawelement-ViewRawElement.md#member-name):
```typescript
rawElement.is( 'img' ); // -> true if this is an img element
rawElement.is( 'rawElement', 'img' ); // -> same as above
text.is( 'img' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L243)
#### Parameters
* `type: 'rawElement' | 'view:rawElement'`
#### Returns
* `this is ViewRawElement`
### `is( type ) → this is ViewEmptyElement` _(inherited)_
Checks whether this object is of type [`ViewEmptyElement`](module_engine_view_emptyelement-ViewEmptyElement.md).
```typescript
emptyElement.is( 'emptyElement' ); // -> true
emptyElement.is( 'element' ); // -> true
emptyElement.is( 'node' ); // -> true
emptyElement.is( 'view:emptyElement' ); // -> true
emptyElement.is( 'view:element' ); // -> true
emptyElement.is( 'view:node' ); // -> true
emptyElement.is( 'model:element' ); // -> false
emptyElement.is( 'documentFragment' ); // -> false
```
Assuming that the object being checked is an empty element, you can also check its [name](module_engine_view_emptyelement-ViewEmptyElement.md#member-name):
```typescript
emptyElement.is( 'element', 'img' ); // -> true if this is a img element
emptyElement.is( 'emptyElement', 'img' ); // -> same as above
text.is( 'element', 'img' ); -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L215)
#### Parameters
* `type: 'emptyElement' | 'view:emptyElement'`
#### Returns
* `this is ViewEmptyElement`
### `is( type ) → this is ViewRange` _(inherited)_
Checks whether this object is of type [`ViewRange`](module_engine_view_range-ViewRange.md).
```typescript
range.is( 'range' ); // -> true
range.is( 'view:range' ); // -> true
range.is( 'model:range' ); // -> false
range.is( 'element' ); // -> false
range.is( 'selection' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L385)
#### Parameters
* `type: 'range' | 'view:range'`
#### Returns
* `this is ViewRange`
### `is( type ) → this is ViewDocumentSelection` _(inherited)_
Checks whether this object is of type [`ViewDocumentSelection`](module_engine_view_documentselection-ViewDocumentSelection.md).
```typescript
`docSelection.is( 'selection' ); // -> true
docSelection.is( 'documentSelection' ); // -> true
docSelection.is( 'view:selection' ); // -> true
docSelection.is( 'view:documentSelection' ); // -> true
docSelection.is( 'model:documentSelection' ); // -> false
docSelection.is( 'element' ); // -> false
docSelection.is( 'node' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L420)
#### Parameters
* `type: 'documentSelection' | 'view:documentSelection'`
#### Returns
* `this is ViewDocumentSelection`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewAttributeElement`](module_engine_view_attributeelement-ViewAttributeElement.md) and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L443)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'attributeElement' | 'view:attributeElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewEditableElement`](module_engine_view_editableelement-ViewEditableElement.md) or its subclass and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L463)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'editableElement' | 'view:editableElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewRawElement`](module_engine_view_rawelement-ViewRawElement.md) and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L480)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'rawElement' | 'view:rawElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewUIElement`](module_engine_view_uielement-ViewUIElement.md) and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L495)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'uiElement' | 'view:uiElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewRootEditableElement`](module_engine_view_rooteditableelement-ViewRootEditableElement.md) and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L488)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'rootElement' | 'view:rootElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewEmptyElement`](module_engine_view_emptyelement-ViewEmptyElement.md) has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L473)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'emptyElement' | 'view:emptyElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewContainerElement`](module_engine_view_containerelement-ViewContainerElement.md) or its subclass and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L451)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'containerElement' | 'view:containerElement'`
* `name: N`
#### Returns
* `boolean`
### `is( type, name ) → boolean` _(inherited)_
Checks whether the object is of type [`ViewElement`](module_engine_view_element-ViewElement.md) or its subclass and has the specified `name`.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L427)
#### Type parameters
* `N: extends string`
#### Parameters
* `type: 'element' | 'view:element'`
* `name: N`
#### Returns
* `boolean`
### `is( type ) → this is ViewSelection | ViewDocumentSelection` _(inherited)_
Checks whether this object is of type [`ViewSelection`](module_engine_view_selection-ViewSelection.md) or [`ViewDocumentSelection`](module_engine_view_documentselection-ViewDocumentSelection.md).
```typescript
selection.is( 'selection' ); // -> true
selection.is( 'view:selection' ); // -> true
selection.is( 'model:selection' ); // -> false
selection.is( 'element' ); // -> false
selection.is( 'range' ); // -> false
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L402)
#### Parameters
* `type: 'selection' | 'view:selection'`
#### Returns
* `this is ViewSelection | ViewDocumentSelection`
### `is( type ) → this is ViewText | ViewNode | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` _(inherited)_
Checks whether this object is of type [`ViewNode`](module_engine_view_node-ViewNode.md) or its subclass.
This method is useful when processing view objects that are of unknown type. For example, a function may return a [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md) or a [`ViewNode`](module_engine_view_node-ViewNode.md) that can be either a text node or an element. This method can be used to check what kind of object is returned.
```typescript
someObject.is( 'element' ); // -> true if this is an element
someObject.is( 'node' ); // -> true if this is a node (a text node or an element)
someObject.is( 'documentFragment' ); // -> true if this is a document fragment
```
Since this method is also available on a range of model objects, you can prefix the type of the object with `model:` or `view:` to check, for example, if this is the model's or view's element:
```typescript
viewElement.is( 'view:element' ); // -> true
viewElement.is( 'model:element' ); // -> false
```
By using this method it is also possible to check a name of an element:
```typescript
imgElement.is( 'element', 'img' ); // -> true
imgElement.is( 'view:element', 'img' ); // -> same as above, but more precise
```
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L57)
#### Parameters
* `type: 'node' | 'view:node'`
#### Returns
* `this is ViewText | ViewNode | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement`
### `isEqual( otherRange ) → boolean`
Two ranges are equal if their start and end positions are equal.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L175)
#### Parameters
* `otherRange: ViewRange`
Range to compare with.
#### Returns
* `boolean`
`true` if ranges are equal, `false` otherwise
### `isIntersecting( otherRange ) → boolean`
Checks and returns whether this range intersects with the given range.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L435)
#### Parameters
* `otherRange: ViewRange`
Range to compare with.
#### Returns
* `boolean`
True if ranges intersect.
### `toJSON() → unknown`
Converts `ViewRange` instance to plain object and returns it.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L444)
#### Returns
* `unknown`
`ViewRange` instance converted to plain object.
#### Static methods
### `_createFromParentsAndOffsets( startElement, startOffset, endElement, endOffset ) → ViewRange` _(internal)_
Creates a range from the given parents and offsets.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L461)
#### Parameters
* `startElement: ViewElement | ViewDocumentFragment`
Start position parent element.
* `startOffset: number`
Start position offset.
* `endElement: ViewElement | ViewDocumentFragment`
End position parent element.
* `endOffset: number`
End position offset.
#### Returns
* `ViewRange`
Created range.
### `_createFromPositionAndShift( position, shift ) → ViewRange` _(internal)_
Creates a new range, spreading from specified [position](module_engine_view_position-ViewPosition.md) to a position moved by given `shift`. If `shift` is a negative value, shifted position is treated as the beginning of the range.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L481)
#### Parameters
* `position: ViewPosition`
Beginning of the range.
* `shift: number`
How long the range should be.
#### Returns
* `ViewRange`
### `_createIn( element ) → ViewRange` _(internal)_
Creates a range inside an [element](module_engine_view_element-ViewElement.md) which starts before the first child of that element and ends after the last child of that element.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L495)
#### Parameters
* `element: ViewElement | ViewDocumentFragment`
Element which is a parent for the range.
#### Returns
* `ViewRange`
### `_createOn( item ) → ViewRange` _(internal)_
Creates a range that starts before given [view item](module_engine_view_item-ViewItem.md) and ends after it.
[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/range.ts#L504)
#### Parameters
* `item: ViewItem`
#### Returns
* `ViewRange`
---
Full index of the CKEditor 5 API reference: [llms.txt](llms.txt)