# ViewPosition

class

Position in the view tree. Position is represented by its parent node and an offset in this parent.

In order to create a new position instance use the `createPosition*()` factory methods available in:

* [`EditingView`](module_engine_view_view-EditingView.md)
* [`ViewDowncastWriter`](module_engine_view_downcastwriter-ViewDowncastWriter.md)
* [`ViewUpcastWriter`](module_engine_view_upcastwriter-ViewUpcastWriter.md)

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L31)

<a id="properties">

## Properties

<a id="member-editableElement">

### `editableElement: ViewEditableElement | null` _(readonly)_

[ViewEditableElement](module_engine_view_editableelement-ViewEditableElement.md) instance that contains this position, or `null` if position is not inside an editable element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L106)

<a id="member-isAtEnd">

### `isAtEnd: boolean` _(readonly)_

Is `true` if position is at the end of its [parent](#member-parent), `false` otherwise.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L89)

<a id="member-isAtStart">

### `isAtStart: boolean` _(readonly)_

Is `true` if position is at the beginning of its [parent](#member-parent), `false` otherwise.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L82)

<a id="member-nodeAfter">

### `nodeAfter: ViewNode | null` _(readonly)_

Node directly after the position. Equals `null` when there is no node after position or position is located inside text node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L59)

<a id="member-nodeBefore">

### `nodeBefore: ViewNode | null` _(readonly)_

Node directly before the position. Equals `null` when there is no node before position or position is located inside text node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L71)

<a id="member-offset">

### `offset: number`

Position offset.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L40)

<a id="member-parent">

### `parent: ViewNode | ViewDocumentFragment` _(readonly)_

Position parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L35)

<a id="member-root">

### `root: ViewNode | ViewDocumentFragment` _(readonly)_

Position's root, that is the root of the position's parent element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L98)

<a id="methods">

## Methods

<a id="function-constructor">

### `constructor( parent, offset )`

Creates a position.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L48)

#### Parameters

* `parent: ViewNode | ViewDocumentFragment`

  Position parent.

* `offset: number`

  Position offset.

<a id="function-clone">

### `clone() → ViewPosition`

Clones this position.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L282)

#### Returns

* `ViewPosition`

<a id="function-compareWith">

### `compareWith( otherPosition ) → ViewPositionRelation`

Checks whether this position is before, after or in same position that other position. Two positions may be also different when they are located in separate roots.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L235)

#### Parameters

* `otherPosition: ViewPosition`

  Position to compare with.

#### Returns

* `ViewPositionRelation`

<a id="function-getAncestors">

### `getAncestors() → Array<ViewNode | ViewDocumentFragment>`

Returns ancestors array of this position, that is this position's parent and it's ancestors.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L166)

#### Returns

* `Array<ViewNode | ViewDocumentFragment>`

  Array with ancestors.

<a id="function-getCommonAncestor">

### `getCommonAncestor( position ) → ViewNode | ViewDocumentFragment | null`

Returns a [`ViewNode`](module_engine_view_node-ViewNode.md) or [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md) which is a common ancestor of both positions.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L178)

#### Parameters

* `position: ViewPosition`

#### Returns

* `ViewNode | ViewDocumentFragment | null`

<a id="function-getLastMatchingPosition">

### `getLastMatchingPosition( skip, options ) → ViewPosition`

Gets the farthest position which matches the callback using [TreeWalker](module_engine_view_treewalker-ViewTreeWalker.md).

For example:

```typescript
getLastMatchingPosition( value => value.type == 'text' ); // <p>{}foo</p> -> <p>foo[]</p>
getLastMatchingPosition( value => value.type == 'text', { direction: 'backward' } ); // <p>foo[]</p> -> <p>{}foo</p>
getLastMatchingPosition( value => false ); // Do not move the position.
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L152)

#### Parameters

* `skip: ( value: ViewTreeWalkerValue ) => boolean`

  Callback function. Gets [`ViewTreeWalkerValue`](module_engine_view_treewalker-ViewTreeWalkerValue.md) and should return `true` if the value should be skipped or `false` if not.

* `options: ViewTreeWalkerOptions`

  Object with configuration options. See [`ViewTreeWalker`](module_engine_view_treewalker-ViewTreeWalker.md).

  Defaults to `{}`

#### Returns

* `ViewPosition`

  The position after the last item which matches the `skip` callback test.

<a id="function-getShiftedBy">

### `getShiftedBy( shift ) → ViewPosition`

Returns a new instance of Position with offset incremented by `shift` value.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L126)

#### Parameters

* `shift: number`

  How position offset should get changed. Accepts negative values.

#### Returns

* `ViewPosition`

  Shifted position.

<a id="function-getWalker">

### `getWalker( options ) → ViewTreeWalker`

Creates a [TreeWalker](module_engine_view_treewalker-ViewTreeWalker.md) instance with this positions as a start position.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L273)

#### Parameters

* `options: ViewTreeWalkerOptions`

  Object with configuration options. See [`ViewTreeWalker`](module_engine_view_treewalker-ViewTreeWalker.md)

  Defaults to `{}`

#### Returns

* `ViewTreeWalker`

<a id="function-is:ELEMENT">

### `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 <img> 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`

<a id="function-is:ATTRIBUTE_ELEMENT">

### `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`

<a id="function-is:EDITABLE_ELEMENT">

### `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`

<a id="function-is:ROOT_ELEMENT">

### `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`

<a id="function-is:RAW_ELEMENT">

### `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`

<a id="function-is:EMPTY_ELEMENT">

### `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`

<a id="function-is:CONTAINER_ELEMENT">

### `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`

<a id="function-is:UI_ELEMENT">

### `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`

<a id="function-is:DOCUMENT_FRAGMENT">

### `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`

<a id="function-is:POSITION">

### `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`

<a id="function-is:SELECTION">

### `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`

<a id="function-is:ELEMENT_NAME">

### `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`

<a id="function-is:CONTAINER_ELEMENT_NAME">

### `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`

<a id="function-is:EMPTY_ELEMENT_NAME">

### `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`

<a id="function-is:ROOT_ELEMENT_NAME">

### `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`

<a id="function-is:UI_ELEMENT_NAME">

### `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`

<a id="function-is:RAW_ELEMENT_NAME">

### `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`

<a id="function-is:EDITABLE_ELEMENT_NAME">

### `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`

<a id="function-is:ATTRIBUTE_ELEMENT_NAME">

### `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`

<a id="function-is:DOCUMENT_SELECTION">

### `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`

<a id="function-is:RANGE">

### `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`

<a id="function-is:TEXT_PROXY">

### `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`

<a id="function-is:TEXT">

### `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`

<a id="function-is:NODE">

### `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`

<a id="function-isAfter">

### `isAfter( otherPosition ) → boolean`

Checks whether this position is located after given position. When method returns `false` it does not mean that this position is before give one. Two positions may be located inside separate roots and in that situation this method will still return `false`.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L225)

#### Parameters

* `otherPosition: ViewPosition`

  Position to compare with.

#### Returns

* `boolean`

  Returns `true` if this position is after given position.

#### Related:

* [ViewPosition#isBefore](#function-isBefore)
* [ViewPosition#compareWith](#function-compareWith)

<a id="function-isBefore">

### `isBefore( otherPosition ) → boolean`

Checks whether this position is located before given position. When method returns `false` it does not mean that this position is after give one. Two positions may be located inside separate roots and in that situation this method will still return `false`.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L211)

#### Parameters

* `otherPosition: ViewPosition`

  Position to compare with.

#### Returns

* `boolean`

  Returns `true` if this position is before given position.

#### Related:

* [ViewPosition#isAfter](#function-isAfter)
* [ViewPosition#compareWith](#function-compareWith)

<a id="function-isEqual">

### `isEqual( otherPosition ) → boolean`

Checks whether this position equals given position.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L197)

#### Parameters

* `otherPosition: ViewPosition`

  Position to compare with.

#### Returns

* `boolean`

  True if positions are same.

<a id="function-toJSON">

### `toJSON() → unknown`

Converts `ViewPosition` instance to plain object and returns it.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L291)

#### Returns

* `unknown`

  `ViewPosition` instance converted to plain object.

#### Static methods

<a id="static-function-_createAfter">

### `_createAfter( item ) → ViewPosition` _(internal)_

Creates a new position after given view item.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L346)

#### Parameters

* `item: ViewItem`

  View item after which the position should be located.

#### Returns

* `ViewPosition`

<a id="static-function-_createAt">

### `_createAt( itemOrPosition, offset? ) → ViewPosition` _(internal)_

Creates position at the given location. The location can be specified as:

* a [position](module_engine_view_position-ViewPosition.md),
* parent element and offset (offset defaults to `0`),
* parent element and `'end'` (sets position at the end of that element),
* [view item](module_engine_view_item-ViewItem.md) and `'before'` or `'after'` (sets position before or after given view item).

This method is a shortcut to other constructors such as:

* [`_createBefore`](#static-function-_createBefore),
* [`_createAfter`](#static-function-_createAfter).

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L314)

#### Parameters

* `itemOrPosition: ViewPosition | ViewItem`

* `offset?: ViewPositionOffset`

  Offset or one of the flags. Used only when first parameter is a [view item](module_engine_view_item-ViewItem.md).

#### Returns

* `ViewPosition`

<a id="static-function-_createBefore">

### `_createBefore( item ) → ViewPosition` _(internal)_

Creates a new position before given view item.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/position.ts#L371)

#### Parameters

* `item: ViewItem`

  View item before which the position should be located.

#### Returns

* `ViewPosition`

---

Full index of the CKEditor 5 API reference: [llms.txt](llms.txt)