Mapper (engine/conversion)

@ckeditor/ckeditor5-engine/src/conversion/mapper

class

Maps elements, positions and markers between the view and the model.

The instance of the Mapper used for the editing pipeline is available in editor.editing.mapper.

Mapper uses bound elements to find corresponding elements and positions, so, to get proper results, all model elements should be bound.

To map the complex model to/from view relations, you may provide custom callbacks for the modelToViewPosition event and viewToModelPosition event that are fired whenever a position mapping request occurs. Those events are fired by the toViewPosition and toModelPosition methods. Mapper adds its own default callbacks with 'lowest' priority. To override default Mapper mapping, add custom callback with higher priority and stop the event.

Filtering

Public
Inherited
Mixed
Protected
Private
Deprecated

Properties

_deferredBindingRemovals : Map.<Element, DocumentFragment>

private

The map of removed view elements with their current root (used for deferred unbinding).

See source
_elementToMarkerNames : Map

private

View element to model marker names mapping.

See source

This is reverse to _markerNameToElements map.
_markerNameToElements : Map

private

Model marker name to view elements mapping.

See source

Keys are Strings while values are Sets with view elements. One marker (name) can be mapped to multiple elements.
_modelToViewMapping : WeakMap

private

Model element to view element mapping.

See source
_unboundMarkerNames : Set.<Marker>

private

Stores marker names of markers which have changed due to unbinding a view element (so it is assumed that the view element has been removed, moved or renamed).

See source
_viewToModelLengthCallbacks : Map

private

A map containing callbacks between view element names and functions evaluating length of view elements in model.

See source
_viewToModelMapping : WeakMap

private

View element to model element mapping.

See source

Methods

constructor()

Creates an instance of the mapper.

See source
bindElementToMarker( element, name )

Binds the given marker name with the given view element. The element will be added to the current set of elements bound with the given marker name.

See source

Parameters

element : Element

Element to bind.

name : String

Marker name.
bindElements( modelElement, viewElement )

Marks model and view elements as corresponding. Corresponding elements can be retrieved by using the toModelElement and toViewElement methods. The information that elements are bound is also used to translate positions.

See source

Parameters

modelElement : Element

Model element.

viewElement : Element

View element.
clearBindings()

Removes all model to view and view to model bindings.

See source
delegate( events ) → EmitterMixinDelegateChain

mixed
Delegates selected events to another Emitter. For instance:

See source
```
emitterA.delegate( 'eventX' ).to( emitterB );
emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
```
then eventX is delegated (fired by) emitterB and emitterC along with data:
```
emitterA.fire( 'eventX', data );
```
and eventY is delegated (fired by) emitterC along with data:
```
emitterA.fire( 'eventY', data );
```
Parameters

events : String

Event names that will be delegated to another emitter.

Returns

EmitterMixinDelegateChain
findMappedViewAncestor( viewPosition ) → Element

For the given viewPosition, finds and returns the closest ancestor of this position that has a mapping to the model.

See source

Parameters

viewPosition : Position

Position for which a mapped ancestor should be found.

Returns

Element

`findPositionIn( viewParent, expectedOffset ) → Position`

Finds the position in the view node (or in its children) with the expected model offset.

See source

Example:

<p>fo<b>bar</b>bom</p> -> expected offset: 4

findPositionIn( p, 4 ):
<p>|fo<b>bar</b>bom</p> -> expected offset: 4, actual offset: 0
<p>fo|<b>bar</b>bom</p> -> expected offset: 4, actual offset: 2
<p>fo<b>bar</b>|bom</p> -> expected offset: 4, actual offset: 5 -> we are too far

findPositionIn( b, 4 - ( 5 - 3 ) ):
<p>fo<b>|bar</b>bom</p> -> expected offset: 2, actual offset: 0
<p>fo<b>bar|</b>bom</p> -> expected offset: 2, actual offset: 3 -> we are too far

findPositionIn( bar, 2 - ( 3 - 3 ) ):
We are in the text node so we can simple find the offset.
<p>fo<b>ba|r</b>bom</p> -> expected offset: 2, actual offset: 2 -> position found

Parameters

viewParent : Element: Tree view element in which we are looking for the position.
expectedOffset : Number: Expected offset.

Returns

Position: Found position.

fire( eventOrInfo, [ args ] ) → *

mixed

Fires an event, executing all callbacks registered for it.

See source

The first parameter passed to callbacks is an EventInfo object, followed by the optional args provided in the fire() method call.

Parameters

eventOrInfo : String | EventInfo

The name of the event or EventInfo object if event is delegated.

[ args ] : *

Additional arguments to be passed to the callbacks.

Returns

*

By default the method returns undefined. However, the return value can be changed by listeners through modification of the evt.return's property (the event info is the first param of every callback).
flushDeferredBindings()

Unbinds all deferred binding removals of view elements that in the meantime were not re-attached to some root or document fragment.

See source

See: unbindViewElement().
flushUnboundMarkerNames() → Array.<String>

Returns all marker names of markers which have changed due to unbinding a view element (so it is assumed that the view element has been removed, moved or renamed) since the last flush. After returning, the marker names list is cleared.

See source

Returns

Array.<String>
getModelLength( viewNode ) → Number
Gets the length of the view element in the model.

See source
The length is calculated as follows:
- if a length mapping callback is provided for the given viewNode, it is used to evaluate the model length (viewNode is used as first and only parameter passed to the callback),
- length of a text node is equal to the length of its data,
- length of a ui element is equal to 0,
- length of a mapped element is equal to 1,
- length of a non-mapped element is equal to the length of its children.
Examples:
```
foo -> 3 // Text length is equal to its data length.
foo -> 1 // Length of an element which is mapped is by default equal to 1.
foo -> 3 // Length of an element which is not mapped is a length of its children.
<div>xy</div> -> 2 // Assuming that <div> is not mapped and are mapped.
```
Parameters

viewNode : Element

View node.

Returns

Number

Length of the node in the tree model.
listenTo( emitter, event, callback, [ options ] = { [options.priority] } )

mixed
Registers a callback function to be executed when an event is fired in a specific (emitter) object.

See source
Events can be grouped in namespaces using :. When namespaced event is fired, it additionally fires all callbacks for that namespace.
```
// myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
myEmitter.on( 'myGroup', genericCallback );
myEmitter.on( 'myGroup:myEvent', specificCallback );

// genericCallback is fired.
myEmitter.fire( 'myGroup' );
// both genericCallback and specificCallback are fired.
myEmitter.fire( 'myGroup:myEvent' );
// genericCallback is fired even though there are no callbacks for "foo".
myEmitter.fire( 'myGroup:foo' );
```
An event callback can stop the event and set the return value of the fire method.

Parameters

emitter : Emitter

The object that fires the event.

event : String

The name of the event.

callback : function

The function to be called on event.

[ options ] : Object

Additional options.

Properties

[ options.priority ] : PriorityString | Number

The priority of this event callback. The higher the priority value the sooner the callback will be fired. Events having the same priority are called in the order they were added.

Defaults to 'normal'

Defaults to {}
markerNameToElements( name ) → Set.<Element> | null

Gets all view elements bound to the given marker name.

See source

Parameters

name : String

Marker name.

Returns

Set.<Element> | null

View elements bound with the given marker name or null if no elements are bound to the given marker name.
off( event, callback )

mixed

Stops executing the callback on the given event. Shorthand for this.stopListening( this, event, callback ).

See source

Parameters

event : String

The name of the event.

callback : function

The function to stop being called.
on( event, callback, [ options ] = { [options.priority] } )

mixed

Registers a callback function to be executed when an event is fired.

See source

Shorthand for this.listenTo( this, event, callback, options ) (it makes the emitter listen on itself).

Parameters

event : String

The name of the event.

callback : function

The function to be called on event.

[ options ] : Object

Additional options.

Properties

[ options.priority ] : PriorityString | Number

The priority of this event callback. The higher the priority value the sooner the callback will be fired. Events having the same priority are called in the order they were added.

Defaults to 'normal'

Defaults to {}
once( event, callback, [ options ] = { [options.priority] } )

mixed

Registers a callback function to be executed on the next time the event is fired only. This is similar to calling on followed by off in the callback.

See source

Parameters

event : String

The name of the event.

callback : function

The function to be called on event.

[ options ] : Object

Additional options.

Properties

[ options.priority ] : PriorityString | Number

The priority of this event callback. The higher the priority value the sooner the callback will be fired. Events having the same priority are called in the order they were added.

Defaults to 'normal'

Defaults to {}
registerViewToModelLength( viewElementName, lengthCallback )
Registers a callback that evaluates the length in the model of a view element with the given name.

See source
The callback is fired with one argument, which is a view element instance. The callback is expected to return a number representing the length of the view element in the model.
```
// List item in view may contain nested list, which have other list items. In model though,
// the lists are represented by flat structure. Because of those differences, length of list view element
// may be greater than one. In the callback it's checked how many nested list items are in evaluated list item.

function getViewListItemLength( element ) {
	let length = 1;

	for ( let child of element.getChildren() ) {
		if ( child.name == 'ul' || child.name == 'ol' ) {
			for ( let item of child.getChildren() ) {
				length += getViewListItemLength( item );
			}
		}
	}

	return length;
}

mapper.registerViewToModelLength( 'li', getViewListItemLength );
```
Parameters

viewElementName : String

Name of view element for which callback is registered.

lengthCallback : function

Function return a length of view element instance in model.
stopDelegating( [ event ], [ emitter ] )

mixed
Stops delegating events. It can be used at different levels:

See source
- To stop delegating all events.
- To stop delegating a specific event to all emitters.
- To stop delegating a specific event to a specific emitter.
Parameters

[ event ] : String

The name of the event to stop delegating. If omitted, stops it all delegations.

[ emitter ] : Emitter

(requires event) The object to stop delegating a particular event to. If omitted, stops delegation of event to all emitters.
stopListening( [ emitter ], [ event ], [ callback ] )

mixed
Stops listening for events. It can be used at different levels:

See source
- To stop listening to a specific callback.
- To stop listening to a specific event.
- To stop listening to all events fired by a specific object.
- To stop listening to all events fired by all objects.
Parameters

[ emitter ] : Emitter

The object to stop listening to. If omitted, stops it for all objects.

[ event ] : String

(Requires the emitter) The name of the event to stop listening to. If omitted, stops it for all events from emitter.

[ callback ] : function

(Requires the event) The function to be removed from the call list for the given event.
toModelElement( viewElement ) → Element | undefined

Gets the corresponding model element.

See source

Note: UIElement does not have corresponding element in model.

Parameters

viewElement : Element

View element.

Returns

Element | undefined

Corresponding model element or undefined if not found.
toModelPosition( viewPosition ) → Position
Gets the corresponding model position.

See source
Parameters

viewPosition : Position

View position.

Returns

Position

Corresponding model position.

Fires
- viewToModelPosition
toModelRange( viewRange ) → Range

Gets the corresponding model range.

See source

Parameters

viewRange : Range

View range.

Returns

Range

Corresponding model range.
toViewElement( modelElement ) → Element | undefined

Gets the corresponding view element.

See source

Parameters

modelElement : Element

Model element.

Returns

Element | undefined

Corresponding view element or undefined if not found.
toViewPosition( modelPosition, [ options ] = { [options.isPhantom] } ) → Position
Gets the corresponding view position.

See source
Parameters

modelPosition : Position

Model position.

[ options ] : Object

Additional options for position mapping process.

Properties

[ options.isPhantom ] : Boolean

Should be set to true if the model position to map is pointing to a place in model tree which no longer exists. For example, it could be an end of a removed model range.

Defaults to false

Returns

Position

Corresponding view position.

Fires
- modelToViewPosition
toViewRange( modelRange ) → Range

Gets the corresponding view range.

See source

Parameters

modelRange : Range

Model range.

Returns

Range

Corresponding view range.
unbindElementFromMarkerName( element, name )

Unbinds an element from given marker name.

See source

Parameters

element : Element

Element to unbind.

name : String

Marker name.
unbindModelElement( modelElement )

Unbinds the given model element from the map.

See source

Note: the model-to-view binding will be removed, if it existed. However, the corresponding view-to-model binding will be removed only if the view element is still bound to the passed modelElement.

This behavior lets for re-binding view element to another model element without fear of losing the new binding when the previously bound model element is unbound.

Parameters

modelElement : Element

Model element to unbind.
unbindViewElement( viewElement, [ options ] = { [options.defer] } )

Unbinds the given view element from the map.

See source

Note: view-to-model binding will be removed, if it existed. However, corresponding model-to-view binding will be removed only if model element is still bound to the passed viewElement.

This behavior allows for re-binding model element to another view element without fear of losing the new binding when the previously bound view element is unbound.

Parameters

viewElement : Element

View element to unbind.

[ options ] : Object

The options object.

Properties

[ options.defer ] : Boolean

Controls whether the binding should be removed immediately or deferred until a flushDeferredBindings() call.

Defaults to false

Defaults to {}
_addEventListener( event, callback, [ options ] = { [options.priority] } )

protected mixed

Adds callback to emitter for given event.

See source

Parameters

event : String

The name of the event.

callback : function

The function to be called on event.

[ options ] : Object

Additional options.

Properties

[ options.priority ] : PriorityString | Number

The priority of this event callback. The higher the priority value the sooner the callback will be fired. Events having the same priority are called in the order they were added.

Defaults to 'normal'

Defaults to {}
_removeEventListener( event, callback )

protected mixed

Removes callback from emitter for given event.

See source

Parameters

event : String

The name of the event.

callback : function

The function to stop being called.
_moveViewPositionToTextNode( viewPosition ) → Position

private
Because we prefer positions in the text nodes over positions next to text nodes, if the view position was next to a text node, it moves it into the text node instead.

See source
```
[]foo -> []foo // do not touch if position is not directly next to text
foo[]foo -> foo{}foo // move to text node
[]foo -> {}foo // move to text node
```
Parameters

viewPosition : Position

Position potentially next to the text node.

Returns

Position

Position in the text node if possible.
_toModelOffset( viewParent, viewOffset, viewBlock ) → Number

private
Calculates model offset based on the view position and the block element.

See source
Example:
```
fooba|r // _toModelOffset( b, 2, p ) -> 5
```
Is a sum of:
```
foo|bar // _toModelOffset( p, 3, p ) -> 3
fooba|r // _toModelOffset( b, 2, b ) -> 2
```
Parameters

viewParent : Element

Position parent.

viewOffset : Number

Position offset.

viewBlock : Element

Block used as a base to calculate offset.

Returns

Number

Offset in the model.

Events

modelToViewPosition( eventInfo, data = { data.mapper } )
Fired for each model-to-view position mapping request. The purpose of this event is to enable custom model-to-view position mapping. Callbacks added to this event take model position and are expected to calculate the view position. The calculated view position should be added as a viewPosition value in the data object that is passed as one of parameters to the event callback.

See source
```
// Assume that "captionedImage" model element is converted to <img> and following elements in view,
// and the model element is bound to <img> element. Force mapping model positions inside "captionedImage" to that
// element.
mapper.on( 'modelToViewPosition', ( evt, data ) => {
	const positionParent = modelPosition.parent;

	if ( positionParent.name == 'captionedImage' ) {
		const viewImg = data.mapper.toViewElement( positionParent );
		const viewCaption = viewImg.nextSibling; // The element.

		data.viewPosition = new ViewPosition( viewCaption, modelPosition.offset );

		// Stop the event if other callbacks should not modify calculated value.
		evt.stop();
	}
} );
```
Note: keep in mind that sometimes a "phantom" model position is being converted. A "phantom" model position is a position that points to a nonexistent place in model. Such a position might still be valid for conversion, though (it would point to a correct place in the view when converted). One example of such a situation is when a range is removed from the model, there may be a need to map the range's end (which is no longer a valid model position). To handle such situations, check the data.isPhantom flag:
```
// Assume that there is a "customElement" model element and whenever the position is before it,
// we want to move it to the inside of the view element bound to "customElement".
mapper.on( 'modelToViewPosition', ( evt, data ) => {
	if ( data.isPhantom ) {
		return;
	}

	// Below line might crash for phantom position that does not exist in model.
	const sibling = data.modelPosition.nodeBefore;

	// Check if this is the element we are interested in.
	if ( !sibling.is( 'element', 'customElement' ) ) {
		return;
	}

	const viewElement = data.mapper.toViewElement( sibling );

	data.viewPosition = new ViewPosition( sibling, 0 );

	evt.stop();
} );
```
Note: the default mapping callback is provided with a low priority setting and does not cancel the event, so it is possible to attach a custom callback after a default callback and also use data.viewPosition calculated by the default callback (for example to fix it).

Note: the default mapping callback will not fire if data.viewPosition is already set.

Note: these callbacks are called very often. For efficiency reasons, it is advised to use them only when position mapping between the given model and view elements is unsolvable by using just elements mapping and default algorithm. Also, the condition that checks if a special case scenario happened should be as simple as possible.

Parameters

eventInfo : EventInfo

An object containing information about the fired event.

data : Object

Data pipeline object that can store and pass data between callbacks. The callback should add the viewPosition value to that object with calculated the view position.

Properties

data.mapper : Mapper

Mapper instance that fired the event.
viewToModelPosition( eventInfo, data = { data.mapper } )
Fired for each view-to-model position mapping request. See event-modelToViewPosition.

See source
```
// See example in `modelToViewPosition` event description.
// This custom mapping will map positions from element next to <img> to the "captionedImage" element.
mapper.on( 'viewToModelPosition', ( evt, data ) => {
	const positionParent = viewPosition.parent;

	if ( positionParent.hasClass( 'image-caption' ) ) {
		const viewImg = positionParent.previousSibling;
		const modelImg = data.mapper.toModelElement( viewImg );

		data.modelPosition = new ModelPosition( modelImg, viewPosition.offset );
		evt.stop();
	}
} );
```
Note: the default mapping callback is provided with a low priority setting and does not cancel the event, so it is possible to attach a custom callback after the default callback and also use data.modelPosition calculated by the default callback (for example to fix it).

Note: the default mapping callback will not fire if data.modelPosition is already set.

Note: these callbacks are called very often. For efficiency reasons, it is advised to use them only when position mapping between the given model and view elements is unsolvable by using just elements mapping and default algorithm. Also, the condition that checks if special case scenario happened should be as simple as possible.

Parameters

eventInfo : EventInfo

An object containing information about the fired event.

data : Object

Data pipeline object that can store and pass data between callbacks. The callback should add modelPosition value to that object with calculated model position.

Properties

data.mapper : Mapper

Mapper instance that fired the event.

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

Mapper (engine/conversion)

Filtering

Properties

_deferredBindingRemovals : Map.<Element, DocumentFragment>module:engine/conversion/mapper~Mapper#_deferredBindingRemovals

_elementToMarkerNames : Mapmodule:engine/conversion/mapper~Mapper#_elementToMarkerNames

_markerNameToElements : Mapmodule:engine/conversion/mapper~Mapper#_markerNameToElements

_modelToViewMapping : WeakMapmodule:engine/conversion/mapper~Mapper#_modelToViewMapping

_unboundMarkerNames : Set.<Marker>module:engine/conversion/mapper~Mapper#_unboundMarkerNames

_viewToModelLengthCallbacks : Mapmodule:engine/conversion/mapper~Mapper#_viewToModelLengthCallbacks

_viewToModelMapping : WeakMapmodule:engine/conversion/mapper~Mapper#_viewToModelMapping

Methods

constructor()module:engine/conversion/mapper~Mapper#constructor

bindElementToMarker( element, name )module:engine/conversion/mapper~Mapper#bindElementToMarker

Parameters

bindElements( modelElement, viewElement )module:engine/conversion/mapper~Mapper#bindElements

Parameters

clearBindings()module:engine/conversion/mapper~Mapper#clearBindings

delegate( events ) → EmitterMixinDelegateChainmodule:engine/conversion/mapper~Mapper#delegate

Parameters

Returns

findMappedViewAncestor( viewPosition ) → Elementmodule:engine/conversion/mapper~Mapper#findMappedViewAncestor

Parameters

Returns

findPositionIn( viewParent, expectedOffset ) → Positionmodule:engine/conversion/mapper~Mapper#findPositionIn

Parameters

Returns

fire( eventOrInfo, [ args ] ) → *module:engine/conversion/mapper~Mapper#fire

Parameters

Returns

flushDeferredBindings()module:engine/conversion/mapper~Mapper#flushDeferredBindings

flushUnboundMarkerNames() → Array.<String>module:engine/conversion/mapper~Mapper#flushUnboundMarkerNames

Returns

getModelLength( viewNode ) → Numbermodule:engine/conversion/mapper~Mapper#getModelLength

Parameters

Returns

listenTo( emitter, event, callback, [ options ] = { [options.priority] } )module:engine/conversion/mapper~Mapper#listenTo

Parameters

markerNameToElements( name ) → Set.<Element> | nullmodule:engine/conversion/mapper~Mapper#markerNameToElements

Parameters

Returns

off( event, callback )module:engine/conversion/mapper~Mapper#off

Parameters

on( event, callback, [ options ] = { [options.priority] } )module:engine/conversion/mapper~Mapper#on

Parameters

once( event, callback, [ options ] = { [options.priority] } )module:engine/conversion/mapper~Mapper#once

Parameters

registerViewToModelLength( viewElementName, lengthCallback )module:engine/conversion/mapper~Mapper#registerViewToModelLength

Parameters

stopDelegating( [ event ], [ emitter ] )module:engine/conversion/mapper~Mapper#stopDelegating

Parameters

stopListening( [ emitter ], [ event ], [ callback ] )module:engine/conversion/mapper~Mapper#stopListening

Parameters

toModelElement( viewElement ) → Element | undefinedmodule:engine/conversion/mapper~Mapper#toModelElement

Parameters

Returns

toModelPosition( viewPosition ) → Positionmodule:engine/conversion/mapper~Mapper#toModelPosition

Parameters

Returns

Fires

toModelRange( viewRange ) → Rangemodule:engine/conversion/mapper~Mapper#toModelRange

Parameters

Returns

toViewElement( modelElement ) → Element | undefinedmodule:engine/conversion/mapper~Mapper#toViewElement

Parameters

Returns

toViewPosition( modelPosition, [ options ] = { [options.isPhantom] } ) → Positionmodule:engine/conversion/mapper~Mapper#toViewPosition

Parameters

Returns

Fires

toViewRange( modelRange ) → Rangemodule:engine/conversion/mapper~Mapper#toViewRange

Parameters

Returns

unbindElementFromMarkerName( element, name )module:engine/conversion/mapper~Mapper#unbindElementFromMarkerName

Parameters

unbindModelElement( modelElement )module:engine/conversion/mapper~Mapper#unbindModelElement

Parameters

unbindViewElement( viewElement, [ options ] = { [options.defer] } )module:engine/conversion/mapper~Mapper#unbindViewElement

Parameters

_addEventListener( event, callback, [ options ] = { [options.priority] } )module:engine/conversion/mapper~Mapper#_addEventListener

Parameters

`_deferredBindingRemovals : Map.<Element, DocumentFragment>`

`_elementToMarkerNames : Map`

`_markerNameToElements : Map`

`_modelToViewMapping : WeakMap`

`_unboundMarkerNames : Set.<Marker>`

`_viewToModelLengthCallbacks : Map`

`_viewToModelMapping : WeakMap`

`constructor()`

`bindElementToMarker( element, name )`

`bindElements( modelElement, viewElement )`

`clearBindings()`

`delegate( events ) → EmitterMixinDelegateChain`

`findMappedViewAncestor( viewPosition ) → Element`

`findPositionIn( viewParent, expectedOffset ) → Position`

`fire( eventOrInfo, [ args ] ) → *`

`flushDeferredBindings()`

`flushUnboundMarkerNames() → Array.<String>`

`getModelLength( viewNode ) → Number`

`listenTo( emitter, event, callback, [ options ] = { [options.priority] } )`

`markerNameToElements( name ) → Set.<Element> | null`

`off( event, callback )`

`on( event, callback, [ options ] = { [options.priority] } )`

`once( event, callback, [ options ] = { [options.priority] } )`

`registerViewToModelLength( viewElementName, lengthCallback )`

`stopDelegating( [ event ], [ emitter ] )`

`stopListening( [ emitter ], [ event ], [ callback ] )`

`toModelElement( viewElement ) → Element | undefined`

`toModelPosition( viewPosition ) → Position`

`toModelRange( viewRange ) → Range`

`toViewElement( modelElement ) → Element | undefined`

`toViewPosition( modelPosition, [ options ] = { [options.isPhantom] } ) → Position`

`toViewRange( modelRange ) → Range`

`unbindElementFromMarkerName( element, name )`

`unbindModelElement( modelElement )`

`unbindViewElement( viewElement, [ options ] = { [options.defer] } )`

`_addEventListener( event, callback, [ options ] = { [options.priority] } )`

`_removeEventListener( event, callback )`

`_moveViewPositionToTextNode( viewPosition ) → Position`

`_toModelOffset( viewParent, viewOffset, viewBlock ) → Number`

`modelToViewPosition( eventInfo, data = { data.mapper } )`

`viewToModelPosition( eventInfo, data = { data.mapper } )`