# ModelElement

class

Model element. Type of [node](module_engine_model_node-ModelNode.md) that has a [name](#member-name) and [child nodes](#function-getChildren).

**Important**: see [`ModelNode`](module_engine_model_node-ModelNode.md) to read about restrictions using `Element` and `Node` API.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L27)

<a id="properties">

## Properties

<a id="member-childCount">

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

Number of this element's children.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L66)

<a id="member-document">

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

[Document](module_engine_model_document-ModelDocument.md) that owns this root element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L96)

<a id="member-endOffset">

### `endOffset: number | null` _(readonly)_

Offset at which this node ends in its parent. It is equal to the sum of this node's [start offset](module_engine_model_node-ModelNode.md#member-startOffset) and [offset size](#member-offsetSize). Equals to `null` if the node has no parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L132)

<a id="member-index">

### `index: number | null` _(readonly)_

Index of this node in its parent or `null` if the node has no parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L103)

<a id="member-isEmpty">

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

Is `true` if there are no nodes inside this element, `false` otherwise.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L80)

<a id="member-maxOffset">

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

Sum of [offset sizes](module_engine_model_node-ModelNode.md#member-offsetSize) of all of this element's children.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L73)

<a id="member-name">

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

Element name.

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

<a id="member-nextSibling">

### `nextSibling: ModelNode | null` _(readonly)_

Node's next sibling or `null` if the node is a last child of it's parent or if the node has no parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L143)

<a id="member-offsetSize">

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

Offset size of this node.

Represents how much "offset space" is occupied by the node in its parent. It is important for [position](module_engine_model_position-ModelPosition.md). When node has `offsetSize` greater than `1`, position can be placed between that node start and end. `offsetSize` greater than `1` is for nodes that represents more than one entity, i.e. a [text node](module_engine_model_text-ModelText.md).

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L123)

<a id="member-parent">

### `parent: ModelElement | ModelDocumentFragment | null` _(readonly)_

Parent of this node. It could be [`ModelElement`](module_engine_model_element-ModelElement.md) or [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md). Equals to `null` if the node has no parent.

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

<a id="member-previousSibling">

### `previousSibling: ModelNode | null` _(readonly)_

Node's previous sibling or `null` if the node is a first child of it's parent or if the node has no parent.

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

<a id="member-root">

### `root: ModelNode | ModelDocumentFragment` _(readonly)_

The top-most ancestor of the node. If node has no parent it is the root itself. If the node is a part of [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md), it's `root` is equal to that `DocumentFragment`.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L162)

<a id="member-rootName">

### `rootName: string | undefined` _(readonly)_

Unique root name used to identify this root element by [`ModelDocument`](module_engine_model_document-ModelDocument.md).

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

<a id="member-startOffset">

### `startOffset: number | null` _(readonly)_

Offset at which this node starts in its parent. It is equal to the sum of [offsetSize](#member-offsetSize) of all its previous siblings. Equals to `null` if node has no parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L111)

<a id="member-_index">

### `_index: number | null` _(internal)_

Index of this node in its parent or `null` if the node has no parent.

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

<a id="member-_startOffset">

### `_startOffset: number | null` _(internal)_

Offset at which this node starts in its parent or `null` if the node has no parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L78)

<a id="member-_children">

### `_children: ModelNodeList` _(private)_

List of children nodes.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L36)

<a id="methods">

## Methods

<a id="function-constructor">

### `constructor( name, attrs?, children? )` _(internal)_

Creates a model element.

**Note:** Constructor of this class shouldn't be used directly in the code. Use the [`createElement`](module_engine_model_writer-ModelWriter.md#function-createElement) method instead.

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

#### Parameters

* `name: string`

  Element's name.

* `attrs?: ModelNodeAttributes`

  Element's attributes. See [`toMap`](module_utils_tomap.md#function-toMap) for a list of accepted values.

* `children?: string | ModelItem | Iterable<( string | ModelItem )>`

  One or more nodes to be inserted as children of created element.

<a id="function-findAncestor">

### `findAncestor( parentName, options = { options.includeSelf? } ) → ModelElement | null`

Returns the parent element of the given name. Returns null if the element is not inside the desired parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L183)

#### Parameters

* `parentName: string`

  The name of the parent element to find.

* `options: object`

  Options object.

  Properties

  * `options.includeSelf?: boolean`

    When set to `true` this node will be also included while searching.

  Defaults to `{}`

#### Returns

* `ModelElement | null`

<a id="function-getAncestors">

### `getAncestors( options = { options.includeSelf?, options.parentFirst? } ) → Array<ModelNode | ModelDocumentFragment>` _(inherited)_

Returns ancestors array of this node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L222)

#### Parameters

* `options: object`

  Options object.

  Properties

  * `options.includeSelf?: boolean`

    When set to `true` this node will be also included in parent's array.

  * `options.parentFirst?: boolean`

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

  Defaults to `{}`

#### Returns

* `Array<ModelNode | ModelDocumentFragment>`

  Array with ancestors.

<a id="function-getAttribute">

### `getAttribute( key ) → unknown` _(inherited)_

Gets an attribute value for given key or `undefined` if that attribute is not set on node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L327)

#### Parameters

* `key: string`

  Key of attribute to look for.

#### Returns

* `unknown`

  Attribute value or `undefined`.

<a id="function-getAttributeKeys">

### `getAttributeKeys() → IterableIterator<string>` _(inherited)_

Returns iterator that iterates over this node's attribute keys.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L344)

#### Returns

* `IterableIterator<string>`

<a id="function-getAttributes">

### `getAttributes() → IterableIterator<[ string, unknown ]>` _(inherited)_

Returns iterator that iterates over this node's attributes.

Attributes are returned as arrays containing two items. First one is attribute key and second is attribute value. This format is accepted by native `Map` object and also can be passed in `Node` constructor.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L337)

#### Returns

* `IterableIterator<[ string, unknown ]>`

<a id="function-getChild">

### `getChild( index ) → ModelNode | null`

Gets the child at the given index. Returns `null` if incorrect index was passed.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L90)

#### Parameters

* `index: number`

  Index in this element.

#### Returns

* `ModelNode | null`

  Child node.

<a id="function-getChildAtOffset">

### `getChildAtOffset( offset ) → ModelNode | null`

Gets the child at the given offset. Returns `null` if incorrect index was passed.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L100)

#### Parameters

* `offset: number`

  Offset in this element.

#### Returns

* `ModelNode | null`

  Child node.

<a id="function-getChildIndex">

### `getChildIndex( node ) → number | null`

Returns an index of the given child node. Returns `null` if given node is not a child of this element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L117)

#### Parameters

* `node: ModelNode`

  Child node to look for.

#### Returns

* `number | null`

  Child node's index in this element.

<a id="function-getChildStartOffset">

### `getChildStartOffset( node ) → number | null`

Returns the starting offset of given child. Starting offset is equal to the sum of [offset sizes](module_engine_model_node-ModelNode.md#member-offsetSize) of all node's siblings that are before it. Returns `null` if given node is not a child of this element.

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

#### Parameters

* `node: ModelNode`

  Child node to look for.

#### Returns

* `number | null`

  Child node's starting offset.

<a id="function-getChildren">

### `getChildren() → IterableIterator<ModelNode>`

Returns an iterator that iterates over all of this element's children.

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

#### Returns

* `IterableIterator<ModelNode>`

<a id="function-getCommonAncestor">

### `getCommonAncestor( node, options = { options.includeSelf? } ) → ModelElement | ModelDocumentFragment | null` _(inherited)_

Returns a [`ModelElement`](module_engine_model_element-ModelElement.md) or [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md) which is a common ancestor of both nodes.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L243)

#### Parameters

* `node: ModelNode`

  The second node.

* `options: object`

  Options object.

  Properties

  * `options.includeSelf?: boolean`

    When set to `true` both nodes will be considered "ancestors" too. Which means that if e.g. node A is inside B, then their common ancestor will be B.

  Defaults to `{}`

#### Returns

* `ModelElement | ModelDocumentFragment | null`

<a id="function-getNodeByPath">

### `getNodeByPath( relativePath ) → ModelNode`

Returns a descendant node by its path relative to this element.

```typescript
// <this>a<b>c</b></this>
this.getNodeByPath( [ 0 ] );	 // -> "a"
this.getNodeByPath( [ 1 ] );	 // -> <b>
this.getNodeByPath( [ 1, 0 ] );  // -> "c"
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L165)

#### Parameters

* `relativePath: Array<number>`

  Path of the node to find, relative to this element.

#### Returns

* `ModelNode`

<a id="function-getPath">

### `getPath() → Array<number>` _(inherited)_

Gets path to the node. The path is an array containing starting offsets of consecutive ancestors of this node, beginning from [root](module_engine_model_node-ModelNode.md#member-root), down to this node's starting offset. The path can be used to create [Position](module_engine_model_position-ModelPosition.md) instance.

```typescript
const abc = new Text( 'abc' );
const foo = new Text( 'foo' );
const h1 = new ModelElement( 'h1', null, new Text( 'header' ) );
const p = new ModelElement( 'p', null, [ abc, foo ] );
const div = new ModelElement( 'div', null, [ h1, p ] );
foo.getPath(); // Returns [ 1, 3 ]. `foo` is in `p` which is in `div`. `p` starts at offset 1, while `foo` at 3.
h1.getPath(); // Returns [ 0 ].
div.getPath(); // Returns [].
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L200)

#### Returns

* `Array<number>`

<a id="function-hasAttribute">

### `hasAttribute( key ) → boolean` _(inherited)_

Checks if the node has an attribute with given key.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L317)

#### Parameters

* `key: string`

  Key of attribute to check.

#### Returns

* `boolean`

  `true` if attribute with given key is set on node, `false` otherwise.

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

### `is( type ) → this is ModelElement | ModelRootElement` _(inherited)_

Checks whether the object is of type [`ModelElement`](module_engine_model_element-ModelElement.md) or its subclass.

```typescript
element.is( 'element' ); // -> true
element.is( 'node' ); // -> true
element.is( 'model:element' ); // -> true
element.is( 'model:node' ); // -> true

element.is( 'view:element' ); // -> false
element.is( 'documentSelection' ); // -> false
```

Assuming that the object being checked is an element, you can also check its [name](#member-name):

```typescript
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L81)

#### Parameters

* `type: 'element' | 'model:element'`

#### Returns

* `this is ModelElement | ModelRootElement`

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

### `is( type ) → this is ModelText` _(inherited)_

Checks whether the object is of type [`ModelText`](module_engine_model_text-ModelText.md).

```typescript
text.is( '$text' ); // -> true
text.is( 'node' ); // -> true
text.is( 'model:$text' ); // -> true
text.is( 'model:node' ); // -> true

text.is( 'view:$text' ); // -> false
text.is( 'documentSelection' ); // -> false
```

**Note:** Until version 20.0.0 this method wasn't accepting `'$text'` type. The legacy `'text'` type is still accepted for backward compatibility.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L127)

#### Parameters

* `type: '$text' | 'model:$text'`

#### Returns

* `this is ModelText`

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

### `is( type ) → this is ModelRootElement` _(inherited)_

Checks whether the object is of type [`ModelRootElement`](module_engine_model_rootelement-ModelRootElement.md).

```typescript
rootElement.is( 'rootElement' ); // -> true
rootElement.is( 'element' ); // -> true
rootElement.is( 'node' ); // -> true
rootElement.is( 'model:rootElement' ); // -> true
rootElement.is( 'model:element' ); // -> true
rootElement.is( 'model:node' ); // -> true

rootElement.is( 'view:element' ); // -> false
rootElement.is( 'documentFragment' ); // -> false
```

Assuming that the object being checked is an element, you can also check its [name](#member-name):

```typescript
rootElement.is( 'rootElement', '$root' ); // -> same as above
```

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

#### Parameters

* `type: 'rootElement' | 'model:rootElement'`

#### Returns

* `this is ModelRootElement`

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

### `is( type ) → this is ModelLiveRange` _(inherited)_

Checks whether the object is of type [`ModelLiveRange`](module_engine_model_liverange-ModelLiveRange.md).

```typescript
liveRange.is( 'range' ); // -> true
liveRange.is( 'model:range' ); // -> true
liveRange.is( 'liveRange' ); // -> true
liveRange.is( 'model:liveRange' ); // -> true

liveRange.is( 'view:range' ); // -> false
liveRange.is( 'documentSelection' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L191)

#### Parameters

* `type: 'liveRange' | 'model:liveRange'`

#### Returns

* `this is ModelLiveRange`

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

### `is( type ) → this is ModelDocumentFragment` _(inherited)_

Checks whether the object is of type [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md).

```typescript
docFrag.is( 'documentFragment' ); // -> true
docFrag.is( 'model:documentFragment' ); // -> true

docFrag.is( 'view:documentFragment' ); // -> false
docFrag.is( 'element' ); // -> false
docFrag.is( 'node' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L207)

#### Parameters

* `type: 'documentFragment' | 'model:documentFragment'`

#### Returns

* `this is ModelDocumentFragment`

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

### `is( type ) → this is ModelRange | ModelLiveRange` _(inherited)_

Checks whether the object is of type [`ModelRange`](module_engine_model_range-ModelRange.md) or its subclass.

```typescript
range.is( 'range' ); // -> true
range.is( 'model:range' ); // -> true

range.is( 'view:range' ); // -> false
range.is( 'documentSelection' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L174)

#### Parameters

* `type: 'range' | 'model:range'`

#### Returns

* `this is ModelRange | ModelLiveRange`

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

### `is( type ) → this is ModelLivePosition` _(inherited)_

Checks whether the object is of type [`ModelLivePosition`](module_engine_model_liveposition-ModelLivePosition.md).

```typescript
livePosition.is( 'position' ); // -> true
livePosition.is( 'model:position' ); // -> true
livePosition.is( 'liveposition' ); // -> true
livePosition.is( 'model:livePosition' ); // -> true

livePosition.is( 'view:position' ); // -> false
livePosition.is( 'documentSelection' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L159)

#### Parameters

* `type: 'livePosition' | 'model:livePosition'`

#### Returns

* `this is ModelLivePosition`

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

### `is( type ) → this is ModelPosition | ModelLivePosition` _(inherited)_

Checks whether the object is of type [`ModelPosition`](module_engine_model_position-ModelPosition.md) or its subclass.

```typescript
position.is( 'position' ); // -> true
position.is( 'model:position' ); // -> true

position.is( 'view:position' ); // -> false
position.is( 'documentSelection' ); // -> false
```

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

#### Parameters

* `type: 'position' | 'model:position'`

#### Returns

* `this is ModelPosition | ModelLivePosition`

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

### `is( type ) → this is Marker` _(inherited)_

Checks whether the object is of type [`Marker`](module_engine_model_markercollection-Marker.md).

```typescript
marker.is( 'marker' ); // -> true
marker.is( 'model:marker' ); // -> true

marker.is( 'view:element' ); // -> false
marker.is( 'documentSelection' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L256)

#### Parameters

* `type: 'marker' | 'model:marker'`

#### Returns

* `this is Marker`

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

### `is( type, name ) → boolean` _(inherited)_

Checks whether the object is of type [`ModelRootElement`](module_engine_model_rootelement-ModelRootElement.md) and has the specified `name`.

```typescript
rootElement.is( 'rootElement', '$root' );
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L297)

#### Type parameters

* `N: extends string`

#### Parameters

* `type: 'rootElement' | 'model:rootElement'`
* `name: N`

#### Returns

* `boolean`

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

### `is( type, name ) → boolean` _(inherited)_

Checks whether the object is of type [`ModelElement`](module_engine_model_element-ModelElement.md) or its subclass and has the specified `name`.

```typescript
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L286)

#### Type parameters

* `N: extends string`

#### Parameters

* `type: 'element' | 'model:element'`
* `name: N`

#### Returns

* `boolean`

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

### `is( type ) → this is ModelTextProxy` _(inherited)_

Checks whether the object is of type [`ModelTextProxy`](module_engine_model_textproxy-ModelTextProxy.md).

```typescript
textProxy.is( '$textProxy' ); // -> true
textProxy.is( 'model:$textProxy' ); // -> true

textProxy.is( 'view:$textProxy' ); // -> false
textProxy.is( 'range' ); // -> false
```

**Note:** Until version 20.0.0 this method wasn't accepting `'$textProxy'` type. The legacy `'textProxt'` type is still accepted for backward compatibility.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L274)

#### Parameters

* `type: '$textProxy' | 'model:$textProxy'`

#### Returns

* `this is ModelTextProxy`

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

### `is( type ) → this is ModelDocumentSelection` _(inherited)_

Checks whether the object is of type [`ModelDocumentSelection`](module_engine_model_documentselection-ModelDocumentSelection.md).

```typescript
selection.is( 'selection' ); // -> true
selection.is( 'documentSelection' ); // -> true
selection.is( 'model:selection' ); // -> true
selection.is( 'model:documentSelection' ); // -> true

selection.is( 'view:selection' ); // -> false
selection.is( 'element' ); // -> false
selection.is( 'node' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L241)

#### Parameters

* `type: 'documentSelection' | 'model:documentSelection'`

#### Returns

* `this is ModelDocumentSelection`

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

### `is( type ) → this is ModelSelection | ModelDocumentSelection` _(inherited)_

Checks whether the object is of type [`ModelSelection`](module_engine_model_selection-ModelSelection.md) or [`ModelDocumentSelection`](module_engine_model_documentselection-ModelDocumentSelection.md).

```typescript
selection.is( 'selection' ); // -> true
selection.is( 'model:selection' ); // -> true

selection.is( 'view:selection' ); // -> false
selection.is( 'range' ); // -> false
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L223)

#### Parameters

* `type: 'selection' | 'model:selection'`

#### Returns

* `this is ModelSelection | ModelDocumentSelection`

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

### `is( type ) → this is ModelNode | ModelText | ModelElement | ModelRootElement` _(inherited)_

Checks whether the object is of type [`ModelNode`](module_engine_model_node-ModelNode.md) or its subclass.

This method is useful when processing model objects that are of unknown type. For example, a function may return a [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md) or a [`ModelNode`](module_engine_model_node-ModelNode.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 view 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
modelElement.is( 'model:element' ); // -> true
modelElement.is( 'view:element' ); // -> false
```

By using this method it is also possible to check a name of an element:

```typescript
imageElement.is( 'element', 'imageBlock' ); // -> true
imageElement.is( 'element', 'imageBlock' ); // -> same as above
imageElement.is( 'model:element', 'imageBlock' ); // -> same as above, but more precise
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/typecheckable.ts#L56)

#### Parameters

* `type: 'node' | 'model:node'`

#### Returns

* `this is ModelNode | ModelText | ModelElement | ModelRootElement`

<a id="function-isAfter">

### `isAfter( node ) → boolean` _(inherited)_

Returns whether this node is after given node. `false` is returned if nodes are in different trees (for example, in different [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md)s).

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L296)

#### Parameters

* `node: ModelNode`

  Node to compare with.

#### Returns

* `boolean`

<a id="function-isAttached">

### `isAttached() → boolean` _(inherited)_

Returns `true` if the node is inside a document root that is attached to the document.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L176)

#### Returns

* `boolean`

<a id="function-isBefore">

### `isBefore( node ) → boolean` _(inherited)_

Returns whether this node is before given node. `false` is returned if nodes are in different trees (for example, in different [`ModelDocumentFragment`](module_engine_model_documentfragment-ModelDocumentFragment.md)s).

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L262)

#### Parameters

* `node: ModelNode`

  Node to compare with.

#### Returns

* `boolean`

<a id="function-offsetToIndex">

### `offsetToIndex( offset ) → number`

Returns index of a node that occupies given offset. If given offset is too low, returns `0`. If given offset is too high, returns [index after last child](#function-getChildIndex).

```typescript
const textNode = new Text( 'foo' );
const pElement = new Element( 'p' );
const divElement = new Element( [ textNode, pElement ] );
divElement.offsetToIndex( -1 ); // Returns 0, because offset is too low.
divElement.offsetToIndex( 0 ); // Returns 0, because offset 0 is taken by `textNode` which is at index 0.
divElement.offsetToIndex( 1 ); // Returns 0, because `textNode` has `offsetSize` equal to 3, so it occupies offset 1 too.
divElement.offsetToIndex( 2 ); // Returns 0.
divElement.offsetToIndex( 3 ); // Returns 1.
divElement.offsetToIndex( 4 ); // Returns 2. There are no nodes at offset 4, so last available index is returned.
```

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L149)

#### Parameters

* `offset: number`

#### Returns

* `number`

<a id="function-toJSON">

### `toJSON() → unknown`

Converts `Element` instance to plain object and returns it. Takes care of converting all of this element's children.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L202)

#### Returns

* `unknown`

  `Element` instance converted to plain object.

<a id="function-_appendChild">

### `_appendChild( nodes ) → void` _(internal)_

[Inserts](#function-_insertChild) one or more nodes at the end of this element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L239)

#### Parameters

* `nodes: string | ModelItem | Iterable<( string | ModelItem )>`

  Nodes to be inserted.

#### Returns

* `void`

#### Related:

* [ModelWriter#append](module_engine_model_writer-ModelWriter.md#function-append)

<a id="function-_clearAttributes">

### `_clearAttributes() → void` _(internal)_

Removes all attributes from the node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L430)

#### Returns

* `void`

#### Related:

* [ModelWriter#clearAttributes](module_engine_model_writer-ModelWriter.md#function-clearAttributes)

<a id="function-_clone">

### `_clone( deep ) → ModelElement` _(internal)_

Creates a copy of this element and returns it. Created element has the same name and attributes as the original element. If clone is deep, the original element's children are also cloned. If not, then empty element is returned.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L226)

#### Parameters

* `deep: boolean`

  If set to `true` clones element and all its children recursively. When set to `false`, element will be cloned without any child.

  Defaults to `false`

#### Returns

* `ModelElement`

<a id="function-_insertChild">

### `_insertChild( index, items ) → void` _(internal)_

Inserts one or more nodes at the given index and sets [parent](module_engine_model_node-ModelNode.md#member-parent) of these nodes to this element.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L252)

#### Parameters

* `index: number`

  Index at which nodes should be inserted.

* `items: string | ModelItem | Iterable<( string | ModelItem )>`

  Items to be inserted.

#### Returns

* `void`

#### Related:

* [ModelWriter#insert](module_engine_model_writer-ModelWriter.md#function-insert)

<a id="function-_remove">

### `_remove() → void` _(internal)_

Removes this node from its parent.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L385)

#### Returns

* `void`

#### Related:

* [ModelWriter#remove](module_engine_model_writer-ModelWriter.md#function-remove)

<a id="function-_removeAttribute">

### `_removeAttribute( key ) → boolean` _(internal)_

Removes an attribute with given key from the node.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L420)

#### Parameters

* `key: string`

  Key of attribute to remove.

#### Returns

* `boolean`

  `true` if the attribute was set on the element, `false` otherwise.

#### Related:

* [ModelWriter#removeAttribute](module_engine_model_writer-ModelWriter.md#function-removeAttribute)

<a id="function-_removeChildren">

### `_removeChildren( index, howMany ) → Array<ModelNode>` _(internal)_

Removes one or more nodes starting at the given index and sets [parent](module_engine_model_node-ModelNode.md#member-parent) of these nodes to `null`.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L277)

#### Parameters

* `index: number`

  Index of the first node to remove.

* `howMany: number`

  Number of nodes to remove.

  Defaults to `1`

#### Returns

* `Array<ModelNode>`

  Array containing removed nodes.

#### Related:

* [ModelWriter#remove](module_engine_model_writer-ModelWriter.md#function-remove)

<a id="function-_removeChildrenArray">

### `_removeChildrenArray( nodes ) → void` _(internal)_

Removes children nodes provided as an array and sets the [parent](module_engine_model_node-ModelNode.md#member-parent) of these nodes to `null`.

These nodes do not need to be direct siblings.

This method is faster than removing nodes one by one, as it recalculates offsets only once.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L298)

#### Parameters

* `nodes: Array<ModelNode>`

  Array of nodes.

#### Returns

* `void`

<a id="function-_setAttribute">

### `_setAttribute( key, value ) → void` _(internal)_

Sets attribute on the node. If attribute with the same key already is set, it's value is overwritten.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L397)

#### Parameters

* `key: string`

  Key of attribute to set.

* `value: unknown`

  Attribute value.

#### Returns

* `void`

#### Related:

* [ModelWriter#setAttribute](module_engine_model_writer-ModelWriter.md#function-setAttribute)

<a id="function-_setAttributesTo">

### `_setAttributesTo( attrs ) → void` _(internal)_

Removes all attributes from the node and sets given attributes.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/node.ts#L408)

#### Parameters

* `attrs: ModelNodeAttributes`

  Attributes to set. See [`toMap`](module_utils_tomap.md#function-toMap) for a list of accepted values.

#### Returns

* `void`

#### Related:

* [ModelWriter#setAttributes](module_engine_model_writer-ModelWriter.md#function-setAttributes)

#### Static methods

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

### `fromJSON( json ) → ModelElement` _(static)_

Creates an `Element` instance from given plain object (i.e. parsed JSON string). Converts `Element` children to proper nodes.

[See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/element.ts#L313)

#### Parameters

* `json: any`

  Plain object to be converted to `Element`.

#### Returns

* `ModelElement`

  `Element` instance created using given plain object.

---

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