# ModelNode

class

Model node. Most basic structure of model tree.

This is an abstract class that is a base for other classes representing different nodes in model.

**Note:** If a node is detached from the model tree, you can manipulate it using it's API. However, it is **very important** that nodes already attached to model tree should be only changed through [Writer API](module_engine_model_writer-ModelWriter.md).

Changes done by `Node` methods, like [\_insertChild](module_engine_model_element-ModelElement.md#function-_insertChild) or [\_setAttribute](#function-_setAttribute) do not generate [operations](module_engine_model_operation_operation-Operation.md) which are essential for correct editor work if you modify nodes in [document](module_engine_model_document-ModelDocument.md) root.

The flow of working on `Node` (and classes that inherits from it) is as such:

1. You can create a `Node` instance, modify it using it's API.
2. Add `Node` to the model using `Batch` API.
3. Change `Node` that was already added to the model using `Batch` API.

Similarly, you cannot use `Batch` API on a node that has not been added to the model tree, with the exception of [inserting](module_engine_model_writer-ModelWriter.md#function-insert) that node to the model tree.

Be aware that using [remove from Batch API](module_engine_model_writer-ModelWriter.md#function-remove) does not allow to use `Node` API because the information about `Node` is still kept in model document.

In case of [element node](module_engine_model_element-ModelElement.md), adding and removing children also counts as changing a node and follows same rules.

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

<a id="properties">

## Properties

<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](#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-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-_attrs">

### `_attrs: Map<string, unknown>` _(private)_

Attributes set on this node.

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

<a id="methods">

## Methods

<a id="function-constructor">

### `constructor( attrs? )`

Creates a model node.

This is an abstract class, so this constructor should not be used directly.

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

#### Parameters

* `attrs?: ModelNodeAttributes`

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

<a id="function-getAncestors">

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

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`

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

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

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-getCommonAncestor">

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

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-getPath">

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

Gets path to the node. The path is an array containing starting offsets of consecutive ancestors of this node, beginning from [root](#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`

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](module_engine_model_element-ModelElement.md#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: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](module_engine_model_element-ModelElement.md#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: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: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: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: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: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: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: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: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: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: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: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: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`

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`

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`

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-toJSON">

### `toJSON() → unknown`

Converts `Node` to plain object and returns it.

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

#### Returns

* `unknown`

  `Node` converted to plain object.

<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? ) → ModelNode` _(internal)_

Creates a copy of this node, that is a node with exactly same attributes, and returns it.

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

#### Parameters

* `_deep?: boolean`

#### Returns

* `ModelNode`

  Node with same attributes as this node.

<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-_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)

---

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