ModelPosition (engine/model)

@ckeditor/ckeditor5-engine/src/model/position

class

Represents a position in the model tree.

A position is represented by its root and a path in that root.

You can create position instances via its constructor or the createPosition*() factory methods of Model and ModelWriter.

Note: Position is based on offsets, not indexes. This means that a position between two text nodes foo and bar has offset 3, not 1. See path for more information.

Since a position in the model is represented by a position root and position path it is possible to create positions placed in non-existing places. This requirement is important for operational transformation algorithms.

Also, operations kept in the document history are storing positions (and ranges) which were correct when those operations were applied, but may not be correct after the document has changed.

When changes are applied to the model, it may also happen that position parent will change even if position path has not changed. Keep in mind, that if a position leads to non-existing element, parent and some other properties and methods will throw errors.

In most cases, position with wrong path is caused by an error in code, but it is sometimes needed, as described above.

Filtering

Public
Inherited
Internal
Protected
Private
Deprecated

Properties

readonly
index : number

See source
Position offset converted to an index in position's parent node. It is equal to the index of a node after this position. If position is placed in text node, position index is equal to the index of that text node.
readonly
isAtEnd : boolean

See source
Is true if position is at the end of its parent, false otherwise.
readonly
isAtStart : boolean

See source
Is true if position is at the beginning of its parent, false otherwise.
readonly
nodeAfter : null | ModelNode

See source
Node directly after this position. Returns null if this position is at the end of its parent, or if it is in a text node.
readonly
nodeBefore : null | ModelNode

See source
Node directly before this position. Returns null if this position is at the start of its parent, or if it is in a text node.
offset : number

See source
Offset at which this position is located in its parent. It is equal to the last item in position path.

Parameters

newOffset : number
readonly
parent : ModelElement | ModelDocumentFragment

See source
Parent element of this position.

Keep in mind that parent value is calculated when the property is accessed. If position path leads to a non-existing element, parent property will throw error.

Also it is a good idea to cache parent property if it is used frequently in an algorithm (i.e. in a long loop).
readonly
path : readonly Array<number>
See source
Position of the node in the tree. Path contains offsets, not indexes.

Position can be placed before, after or in a node if that node has offsetSize greater than 1. Items in position path are starting offsets of position ancestors, starting from direct root children, down to the position offset in it's parent.
```
ROOT
 |- P            before: [ 0 ]         after: [ 1 ]
 |- UL           before: [ 1 ]         after: [ 2 ]
    |- LI        before: [ 1, 0 ]      after: [ 1, 1 ]
    |  |- foo    before: [ 1, 0, 0 ]   after: [ 1, 0, 3 ]
    |- LI        before: [ 1, 1 ]      after: [ 1, 2 ]
       |- bar    before: [ 1, 1, 0 ]   after: [ 1, 1, 3 ]
```
foo and bar are representing text nodes. Since text nodes has offset size greater than 1 you can place position offset between their start and end:
```
ROOT
 |- P
 |- UL
    |- LI
    |  |- f^o|o  ^ has path: [ 1, 0, 1 ]   | has path: [ 1, 0, 2 ]
    |- LI
       |- b^a|r  ^ has path: [ 1, 1, 1 ]   | has path: [ 1, 1, 2 ]
```
readonly
root : ModelElement | ModelDocumentFragment

See source
Root of the position path.
stickiness : ModelPositionStickiness

See source
Position stickiness. See ModelPositionStickiness.
readonly
textNode : null | ModelText

See source
Returns text node instance in which this position is placed or null if this position is not in a text node.

Methods

constructor( root, path, stickiness )

See source
Creates a position.

Parameters

root : ModelElement | ModelDocumentFragment

Root of the position.

path : readonly Array<number>

Position path. See path.

stickiness : ModelPositionStickiness

Position stickiness. See ModelPositionStickiness.

Defaults to 'toNone'
clone() → this

See source
Returns a new position that is equal to current position.

Returns

this
compareWith( otherPosition ) → ModelPositionRelation

See source
Checks whether this position is before or after given position.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

otherPosition : ModelPosition

Returns

ModelPositionRelation
findAncestor( parentName ) → null | ModelElement

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

Parameters

parentName : string

The name of the parent element to find.

Returns

null | ModelElement
getAncestors() → Array<ModelElement | ModelDocumentFragment>

See source
Returns ancestors array of this position, that is this position's parent and its ancestors.

Returns

Array<ModelElement | ModelDocumentFragment>

Array with ancestors.
getCommonAncestor( position ) → null | ModelElement | ModelDocumentFragment

See source
Returns an ModelElement or ModelDocumentFragment which is a common ancestor of both positions. The roots of these two positions must be identical.

Parameters

position : ModelPosition

The second position.

Returns

null | ModelElement | ModelDocumentFragment
getCommonPath( position ) → Array<number>

See source
Returns the slice of two position paths which is identical. The roots of these two paths must be identical.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

position : ModelPosition

The second position.

Returns

Array<number>

The common path.
getLastMatchingPosition( skip, options ) → ModelPosition
See source
Gets the farthest position which matches the callback using TreeWalker.

For example:
```
getLastMatchingPosition( value => value.type == 'text' );
// <paragraph>[]foo</paragraph> -> <paragraph>foo[]</paragraph>

getLastMatchingPosition( value => value.type == 'text', { direction: 'backward' } );
// <paragraph>foo[]</paragraph> -> <paragraph>[]foo</paragraph>

getLastMatchingPosition( value => false );
// Do not move the position.
```
Parameters

skip : ( value: ModelTreeWalkerValue ) => boolean

Callback function. Gets ModelTreeWalkerValue and should return true if the value should be skipped or false if not.

options : ModelTreeWalkerOptions

Object with configuration options. See ModelTreeWalker.

Defaults to {}

Returns

ModelPosition

The position after the last item which matches the skip callback test.
getParentPath() → Array<number>

See source
Returns a path to this position's parent. Parent path is equal to position path but without the last item.

This method is safe to use it on non-existing positions (for example during operational transformation).

Returns

Array<number>

Path to the parent.
getShiftedBy( shift ) → ModelPosition

See source
Returns a new instance of Position, that has same parent but it's offset is shifted by shift value (can be a negative value).

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

shift : number

Offset shift. Can be a negative value.

Returns

ModelPosition

Shifted position.
getTransformedByOperation( operation ) → ModelPosition

See source
Returns a copy of this position that is transformed by given operation.

The new position's parameters are updated accordingly to the effect of the operation.

For example, if n nodes are inserted before the position, the returned position offset will be increased by n. If the position was in a merged element, it will be accordingly moved to the new element, etc.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

operation : Operation

Operation to transform by.

Returns

ModelPosition

Transformed position.
hasSameParentAs( position ) → boolean

See source
Checks if two positions are in the same parent.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

position : ModelPosition

Position to compare with.

Returns

boolean

true if positions have the same parent, false otherwise.
inherited
is( type ) → this is ModelElement | ModelRootElement
See source
Checks whether the object is of type ModelElement or its subclass.
```
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:
```
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
```
Parameters

type : 'element' | 'model:element'

Returns

this is ModelElement | ModelRootElement

inherited
`is( type ) → this is ModelRootElement`

See source

Checks whether the object is of type ModelRootElement.

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:

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

Parameters

type : 'rootElement' | 'model:rootElement'

Returns

this is ModelRootElement

inherited
is( type ) → this is ModelPosition | ModelLivePosition
See source
Checks whether the object is of type ModelPosition or its subclass.
```
position.is( 'position' ); // -> true
position.is( 'model:position' ); // -> true

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

type : 'position' | 'model:position'

Returns

this is ModelPosition | ModelLivePosition
inherited
is( type ) → this is ModelRange | ModelLiveRange
See source
Checks whether the object is of type ModelRange or its subclass.
```
range.is( 'range' ); // -> true
range.is( 'model:range' ); // -> true

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

type : 'range' | 'model:range'

Returns

this is ModelRange | ModelLiveRange
inherited
is( type ) → this is ModelLivePosition
See source
Checks whether the object is of type ModelLivePosition.
```
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
```
Parameters

type : 'livePosition' | 'model:livePosition'

Returns

this is ModelLivePosition
inherited
is( type ) → this is ModelText
See source
Checks whether the object is of type ModelText.
```
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.

Parameters

type : '$text' | 'model:$text'

Returns

this is ModelText
inherited
is( type ) → this is ModelDocumentFragment
See source
Checks whether the object is of type ModelDocumentFragment.
```
docFrag.is( 'documentFragment' ); // -> true
docFrag.is( 'model:documentFragment' ); // -> true

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

type : 'documentFragment' | 'model:documentFragment'

Returns

this is ModelDocumentFragment
inherited
is( type ) → this is ModelTextProxy
See source
Checks whether the object is of type ModelTextProxy.
```
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.

Parameters

type : '$textProxy' | 'model:$textProxy'

Returns

this is ModelTextProxy
inherited
is( type, name ) → boolean
See source
Checks whether the object is of type ModelRootElement and has the specified name.
```
rootElement.is( 'rootElement', '$root' );
```
Type parameters

N : extends string

Parameters

type : 'rootElement' | 'model:rootElement'

name : N

Returns

boolean
inherited
is( type, name ) → boolean
See source
Checks whether the object is of type ModelElement or its subclass and has the specified name.
```
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
```
Type parameters

N : extends string

Parameters

type : 'element' | 'model:element'

name : N

Returns

boolean
inherited
is( type ) → this is Marker
See source
Checks whether the object is of type Marker.
```
marker.is( 'marker' ); // -> true
marker.is( 'model:marker' ); // -> true

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

type : 'marker' | 'model:marker'

Returns

this is Marker
inherited
is( type ) → this is ModelDocumentSelection
See source
Checks whether the object is of type ModelDocumentSelection.
```
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
```
Parameters

type : 'documentSelection' | 'model:documentSelection'

Returns

this is ModelDocumentSelection
inherited
is( type ) → this is ModelSelection | ModelDocumentSelection
See source
Checks whether the object is of type ModelSelection or ModelDocumentSelection.
```
selection.is( 'selection' ); // -> true
selection.is( 'model:selection' ); // -> true

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

type : 'selection' | 'model:selection'

Returns

this is ModelSelection | ModelDocumentSelection
inherited
is( type ) → this is ModelLiveRange
See source
Checks whether the object is of type ModelLiveRange.
```
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
```
Parameters

type : 'liveRange' | 'model:liveRange'

Returns

this is ModelLiveRange
inherited
is( type ) → this is ModelNode | ModelText | ModelElement | ModelRootElement
See source
Checks whether the object is of type ModelNode or its subclass.

This method is useful when processing model objects that are of unknown type. For example, a function may return a ModelDocumentFragment or a ModelNode that can be either a text node or an element. This method can be used to check what kind of object is returned.
```
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:
```
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:
```
imageElement.is( 'element', 'imageBlock' ); // -> true
imageElement.is( 'element', 'imageBlock' ); // -> same as above
imageElement.is( 'model:element', 'imageBlock' ); // -> same as above, but more precise
```
Parameters

type : 'node' | 'model:node'

Returns

this is ModelNode | ModelText | ModelElement | ModelRootElement
isAfter( otherPosition ) → boolean
See source
Checks whether this position is after given position.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

otherPosition : ModelPosition

Position to compare with.

Returns

boolean

True if this position is after given position.

Related:
- ModelPosition#isBefore
isBefore( otherPosition ) → boolean
See source
Checks whether this position is before given position.

Note: watch out when using negation of the value returned by this method, because the negation will also be true if positions are in different roots and you might not expect this. You should probably use a.isAfter( b ) || a.isEqual( b ) or !a.isBefore( p ) && a.root == b.root in most scenarios. If your condition uses multiple isAfter and isBefore checks, build them so they do not use negated values, i.e.:
```
if ( a.isBefore( b ) && c.isAfter( d ) ) {
	// do A.
} else {
	// do B.
}
```
or, if you have only one if-branch:
```
if ( !( a.isBefore( b ) && c.isAfter( d ) ) {
	// do B.
}
```
rather than:
```
if ( !a.isBefore( b ) || && !c.isAfter( d ) ) {
	// do B.
} else {
	// do A.
}
```
This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

otherPosition : ModelPosition

Position to compare with.

Returns

boolean

True if this position is before given position.
isEqual( otherPosition ) → boolean

See source
Checks whether this position is equal to given position.

This method is safe to use it on non-existing positions (for example during operational transformation).

Parameters

otherPosition : ModelPosition

Position to compare with.

Returns

boolean

True if positions are same.
isTouching( otherPosition ) → boolean

See source
Checks whether this position is touching given position. Positions touch when there are no text nodes or empty nodes in a range between them. Technically, those positions are not equal but in many cases they are very similar or even indistinguishable.

Parameters

otherPosition : ModelPosition

Position to compare with.

Returns

boolean

True if positions touch.
isValid() → boolean

See source
Checks whether the position is valid in current model tree, that is whether it points to an existing place in the model.

Returns

boolean
toJSON() → unknown

See source

Returns

unknown
internal
_getCombined( source, target ) → ModelPosition
See source
Returns a new position that is a combination of this position and given positions.

The combined position is a copy of this position transformed by moving a range starting at source position to the target position. It is expected that this position is inside the moved range.

Example:
```
let original = model.createPositionFromPath( root, [ 2, 3, 1 ] );
let source = model.createPositionFromPath( root, [ 2, 2 ] );
let target = model.createPositionFromPath( otherRoot, [ 1, 1, 3 ] );
original._getCombined( source, target ); // path is [ 1, 1, 4, 1 ], root is `otherRoot`
```
Explanation:

We have a position [ 2, 3, 1 ] and move some nodes from [ 2, 2 ] to [ 1, 1, 3 ]. The original position was inside moved nodes and now should point to the new place. The moved nodes will be after positions [ 1, 1, 3 ], [ 1, 1, 4 ], [ 1, 1, 5 ]. Since our position was in the second moved node, the transformed position will be in a sub-tree of a node at [ 1, 1, 4 ]. Looking at original path, we took care of [ 2, 3 ] part of it. Now we have to add the rest of the original path to the transformed path. Finally, the transformed position will point to [ 1, 1, 4, 1 ].

Parameters

source : ModelPosition

Beginning of the moved range.

target : ModelPosition

Position where the range is moved.

Returns

ModelPosition

Combined position.
internal
_getTransformedByDeletion( deletePosition, howMany ) → null | ModelPosition

See source
Returns a copy of this position that is updated by removing howMany nodes starting from deletePosition. It may happen that this position is in a removed node. If that is the case, null is returned instead.

Parameters

deletePosition : ModelPosition

Position before the first removed node.

howMany : number

How many nodes are removed.

Returns

null | ModelPosition

Transformed position or null.
internal
_getTransformedByInsertOperation( operation ) → ModelPosition

See source
Returns a copy of this position transformed by an insert operation.

Parameters

operation : InsertOperation

Returns

ModelPosition
internal
_getTransformedByInsertion( insertPosition, howMany ) → ModelPosition

See source
Returns a copy of this position that is updated by inserting howMany nodes at insertPosition.

Parameters

insertPosition : ModelPosition

Position where nodes are inserted.

howMany : number

How many nodes are inserted.

Returns

ModelPosition

Transformed position.
internal
_getTransformedByMergeOperation( operation ) → ModelPosition

See source
Returns a copy of this position transformed by merge operation.

Parameters

operation : MergeOperation

Returns

ModelPosition
internal
_getTransformedByMove( sourcePosition, targetPosition, howMany ) → ModelPosition

See source
Returns a copy of this position that is updated by moving howMany nodes from sourcePosition to targetPosition.

Parameters

sourcePosition : ModelPosition

Position before the first element to move.

targetPosition : ModelPosition

Position where moved elements will be inserted.

howMany : number

How many consecutive nodes to move, starting from sourcePosition.

Returns

ModelPosition

Transformed position.
internal
_getTransformedByMoveOperation( operation ) → ModelPosition

See source
Returns a copy of this position transformed by a move operation.

Parameters

operation : MoveOperation

Returns

ModelPosition
internal
_getTransformedBySplitOperation( operation ) → ModelPosition

See source
Returns a copy of this position transformed by a split operation.

Parameters

operation : SplitOperation

Returns

ModelPosition

Static methods

static
fromJSON( json, doc ) → ModelPosition

See source
Creates a Position instance from given plain object (i.e. parsed JSON string).

Parameters

json : any

Plain object to be converted to Position.

doc : ModelDocument

Document object that will be position owner.

Returns

ModelPosition

Position instance created using given plain object.
internal static
_createAfter( item, [ stickiness ] ) → ModelPosition

See source
Creates a new position, after given model item.

Parameters

item : ModelDocumentFragment | ModelItem

Item after which the position should be placed.

[ stickiness ] : ModelPositionStickiness

Position stickiness.

Returns

ModelPosition
internal static
_createAt( itemOrPosition, [ offset ], stickiness ) → ModelPosition
See source
Creates position at the given location. The location can be specified as:
- a position,
- parent element and offset (offset defaults to 0),
- parent element and 'end' (sets position at the end of that element),
- model item and 'before' or 'after' (sets position before or after given model item).
This method is a shortcut to other factory methods such as:
- _createBefore,
- _createAfter.
Parameters

itemOrPosition : ModelDocumentFragment | ModelPosition | ModelItem

[ offset ] : ModelPositionOffset

Offset or one of the flags. Used only when the first parameter is a model item.

stickiness : ModelPositionStickiness

Position stickiness. Used only when the first parameter is a model item.

Defaults to 'toNone'

Returns

ModelPosition
internal static
_createBefore( item, [ stickiness ] ) → ModelPosition

See source
Creates a new position, before the given model item.

Parameters

item : ModelDocumentFragment | ModelItem

Item before which the position should be placed.

[ stickiness ] : ModelPositionStickiness

Position stickiness.

Returns

ModelPosition

Every day, we work hard to keep our documentation complete. Have you spotted outdated information? Is something missing? Please report it via our issue tracker.

With the release of version 42.0.0, we have rewritten much of our documentation to reflect the new import paths and features. We appreciate your feedback to help us ensure its accuracy and completeness.

ModelPosition (engine/model)

Filtering

Properties

readonly index : numbermodule:engine/model/position~ModelPosition#index

readonly isAtEnd : booleanmodule:engine/model/position~ModelPosition#isAtEnd

readonly isAtStart : booleanmodule:engine/model/position~ModelPosition#isAtStart

readonly nodeAfter : null | ModelNodemodule:engine/model/position~ModelPosition#nodeAfter

readonly nodeBefore : null | ModelNodemodule:engine/model/position~ModelPosition#nodeBefore

offset : numbermodule:engine/model/position~ModelPosition#offset

Parameters

readonly parent : ModelElement | ModelDocumentFragmentmodule:engine/model/position~ModelPosition#parent

readonly path : readonly Array<number>module:engine/model/position~ModelPosition#path

readonly root : ModelElement | ModelDocumentFragmentmodule:engine/model/position~ModelPosition#root

stickiness : ModelPositionStickinessmodule:engine/model/position~ModelPosition#stickiness

readonly textNode : null | ModelTextmodule:engine/model/position~ModelPosition#textNode

Methods

constructor( root, path, stickiness )module:engine/model/position~ModelPosition#constructor

Parameters

clone() → thismodule:engine/model/position~ModelPosition#clone

Returns

compareWith( otherPosition ) → ModelPositionRelationmodule:engine/model/position~ModelPosition#compareWith

Parameters

Returns

findAncestor( parentName ) → null | ModelElementmodule:engine/model/position~ModelPosition#findAncestor

Parameters

Returns

getAncestors() → Array<ModelElement | ModelDocumentFragment>module:engine/model/position~ModelPosition#getAncestors

Returns

getCommonAncestor( position ) → null | ModelElement | ModelDocumentFragmentmodule:engine/model/position~ModelPosition#getCommonAncestor

Parameters

Returns

getCommonPath( position ) → Array<number>module:engine/model/position~ModelPosition#getCommonPath

Parameters

Returns

getLastMatchingPosition( skip, options ) → ModelPositionmodule:engine/model/position~ModelPosition#getLastMatchingPosition

Parameters

Returns

getParentPath() → Array<number>module:engine/model/position~ModelPosition#getParentPath

Returns

getShiftedBy( shift ) → ModelPositionmodule:engine/model/position~ModelPosition#getShiftedBy

Parameters

Returns

getTransformedByOperation( operation ) → ModelPositionmodule:engine/model/position~ModelPosition#getTransformedByOperation

Parameters

Returns

hasSameParentAs( position ) → booleanmodule:engine/model/position~ModelPosition#hasSameParentAs

Parameters

Returns

inherited is( type ) → this is ModelElement | ModelRootElementmodule:engine/model/position~ModelPosition#is:ELEMENT

Parameters

Returns

inherited is( type ) → this is ModelRootElementmodule:engine/model/position~ModelPosition#is:ROOT_ELEMENT

Parameters

Returns

inherited is( type ) → this is ModelPosition | ModelLivePositionmodule:engine/model/position~ModelPosition#is:POSITION

Parameters

Returns

inherited is( type ) → this is ModelRange | ModelLiveRangemodule:engine/model/position~ModelPosition#is:RANGE

Parameters

Returns

inherited is( type ) → this is ModelLivePositionmodule:engine/model/position~ModelPosition#is:LIVE_POSITION

Parameters

Returns

inherited is( type ) → this is ModelTextmodule:engine/model/position~ModelPosition#is:TEXT

Parameters

Returns

inherited is( type ) → this is ModelDocumentFragmentmodule:engine/model/position~ModelPosition#is:DOCUMENT_FRAGMENT

Parameters

Returns

inherited is( type ) → this is ModelTextProxymodule:engine/model/position~ModelPosition#is:TEXT_PROXY

Parameters

Returns

inherited is( type, name ) → booleanmodule:engine/model/position~ModelPosition#is:ROOT_ELEMENT_NAME

Type parameters

Parameters

Returns

inherited is( type, name ) → booleanmodule:engine/model/position~ModelPosition#is:ELEMENT_NAME

Type parameters

Parameters

Returns

readonly
`index : number`

readonly
`isAtEnd : boolean`

readonly
`isAtStart : boolean`

readonly
`nodeAfter : null | ModelNode`

readonly
`nodeBefore : null | ModelNode`

`offset : number`

readonly
`parent : ModelElement | ModelDocumentFragment`

readonly
`path : readonly Array<number>`

readonly
`root : ModelElement | ModelDocumentFragment`

`stickiness : ModelPositionStickiness`

readonly
`textNode : null | ModelText`

`constructor( root, path, stickiness )`

`clone() → this`

`compareWith( otherPosition ) → ModelPositionRelation`

`findAncestor( parentName ) → null | ModelElement`

`getAncestors() → Array<ModelElement | ModelDocumentFragment>`

`getCommonAncestor( position ) → null | ModelElement | ModelDocumentFragment`

`getCommonPath( position ) → Array<number>`

`getLastMatchingPosition( skip, options ) → ModelPosition`

`getParentPath() → Array<number>`

`getShiftedBy( shift ) → ModelPosition`

`getTransformedByOperation( operation ) → ModelPosition`

`hasSameParentAs( position ) → boolean`

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

inherited
`is( type ) → this is ModelRootElement`

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

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

inherited
`is( type ) → this is ModelLivePosition`

inherited
`is( type ) → this is ModelText`

inherited
`is( type ) → this is ModelDocumentFragment`

inherited
`is( type ) → this is ModelTextProxy`

inherited
`is( type, name ) → boolean`

inherited
`is( type, name ) → boolean`

inherited
`is( type ) → this is Marker`

inherited
`is( type ) → this is ModelDocumentSelection`

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

inherited
`is( type ) → this is ModelLiveRange`

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

`isAfter( otherPosition ) → boolean`

`isBefore( otherPosition ) → boolean`

`isEqual( otherPosition ) → boolean`

`isTouching( otherPosition ) → boolean`

`isValid() → boolean`

`toJSON() → unknown`

internal
`_getCombined( source, target ) → ModelPosition`

internal
`_getTransformedByDeletion( deletePosition, howMany ) → null | ModelPosition`

internal
`_getTransformedByInsertOperation( operation ) → ModelPosition`

internal
`_getTransformedByInsertion( insertPosition, howMany ) → ModelPosition`

internal
`_getTransformedByMergeOperation( operation ) → ModelPosition`

internal
`_getTransformedByMove( sourcePosition, targetPosition, howMany ) → ModelPosition`

internal
`_getTransformedByMoveOperation( operation ) → ModelPosition`

internal
`_getTransformedBySplitOperation( operation ) → ModelPosition`

static
`fromJSON( json, doc ) → ModelPosition`

internal static
`_createAfter( item, [ stickiness ] ) → ModelPosition`

internal static
`_createAt( itemOrPosition, [ offset ], stickiness ) → ModelPosition`

internal static
`_createBefore( item, [ stickiness ] ) → ModelPosition`