# ViewTextProxy

class

ViewTextProxy is a wrapper for substring of [`ViewText`](module_engine_view_text-ViewText.md). Instance of this class is created by [`ViewTreeWalker`](module_engine_view_treewalker-ViewTreeWalker.md) when only a part of [`ViewText`](module_engine_view_text-ViewText.md) needs to be returned.

`ViewTextProxy` has an API similar to [Text](module_engine_view_text-ViewText.md) and allows to do most of the common tasks performed on view nodes.

**Note:** Some `ViewTextProxy` instances may represent whole text node, not just a part of it. See [`isPartial`](#member-isPartial).

**Note:** `ViewTextProxy` is a readonly interface.

**Note:** `ViewTextProxy` instances are created on the fly basing on the current state of parent [`ViewText`](module_engine_view_text-ViewText.md). Because of this it is highly unrecommended to store references to \`TextProxy instances because they might get invalidated due to operations on Document. Also ViewTextProxy is not a [`ViewNode`](module_engine_view_node-ViewNode.md) so it cannot be inserted as a child of [`ViewElement`](module_engine_view_element-ViewElement.md).

`ViewTextProxy` instances are created by [view tree walker](module_engine_view_treewalker-ViewTreeWalker.md). You should not need to create an instance of this class by your own.

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

<a id="properties">

## Properties

<a id="member-data">

### `data: string` _(readonly)_

Text data represented by this text proxy.

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

<a id="member-document">

### `document: ViewDocument | null` _(readonly)_

[View document](module_engine_view_document-ViewDocument.md) that owns this text proxy, or `null` if the text proxy is inside [document fragment](module_engine_view_documentfragment-ViewDocumentFragment.md).

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

<a id="member-isPartial">

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

Flag indicating whether `ViewTextProxy` instance covers only part of the original [text node](module_engine_view_text-ViewText.md) (`true`) or the whole text node (`false`).

This is `false` when text proxy starts at the very beginning of [textNode](#member-textNode) ([offsetInText](#member-offsetInText) equals `0`) and text proxy sizes is equal to text node size.

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

<a id="member-offsetInText">

### `offsetInText: number` _(readonly)_

Offset in the `textNode` where this `ViewTextProxy` instance starts.

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

<a id="member-offsetSize">

### `offsetSize: number` _(readonly)_

Offset size of this node.

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

<a id="member-parent">

### `parent: ViewElement | ViewDocumentFragment | null` _(readonly)_

Parent of this text proxy, which is same as parent of text node represented by this text proxy.

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

<a id="member-root">

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

Root of this text proxy, which is same as root of text node represented by this text proxy.

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

<a id="member-textNode">

### `textNode: ViewText` _(readonly)_

Reference to the [`ViewText`](module_engine_view_text-ViewText.md) element which ViewTextProxy is a substring.

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

<a id="methods">

## Methods

<a id="function-constructor">

### `constructor( textNode, offsetInText, length )` _(internal)_

Creates a text proxy.

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

#### Parameters

* `textNode: ViewText`

  Text node which part is represented by this text proxy.

* `offsetInText: number`

  Offset in [text node](#member-textNode) from which the text proxy starts.

* `length: number`

  Text proxy length, that is how many text node's characters, starting from `offsetInText` it represents.

<a id="function-getAncestors">

### `getAncestors( options = { options.includeSelf?, options.parentFirst? } ) → Array<ViewText | ViewElement | ViewDocumentFragment>`

Returns ancestors array of this text proxy.

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

#### Parameters

* `options: object`

  Options object.

  Properties

  * `options.includeSelf?: boolean`

    When set to `true`, textNode will be also included in parent's array.

  * `options.parentFirst?: boolean`

    When set to `true`, array will be sorted from text proxy parent to root element, otherwise root element will be the first item in the array.

  Defaults to `{}`

#### Returns

* `Array<ViewText | ViewElement | ViewDocumentFragment>`

  Array with ancestors.

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

---

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