# Marker class `Marker` is a continuous part of the model (like a range), is named and represents some kind of information about the marked part of the model document. In contrary to [nodes](module_engine_model_node-ModelNode.md), which are building blocks of the model document tree, markers are not stored directly in the document tree but in the [model markers' collection](module_engine_model_model-Model.md#member-markers). Still, they are document data, by giving additional meaning to the part of a model document between marker start and marker end. In this sense, markers are similar to adding and converting attributes on nodes. The difference is that attribute is connected with a given node (e.g. a character is bold no matter if it gets moved or content around it changes). Markers on the other hand are continuous ranges and are characterized by their start and end position. This means that any character in the marker is marked by the marker. For example, if a character is moved outside of marker it stops being "special" and the marker is shrunk. Similarly, when a character is moved into the marker from other place in document model, it starts being "special" and the marker is enlarged. Another upside of markers is that finding marked part of document is fast and easy. Using attributes to mark some nodes and then trying to find that part of document would require traversing whole document tree. Marker gives instant access to the range which it is marking at the moment. Markers are built from a name and a range. Range of the marker is updated automatically when document changes, using [live range](module_engine_model_liverange-ModelLiveRange.md) mechanism. Name is used to group and identify markers. Names have to be unique, but markers can be grouped by using common prefixes, separated with `:`, for example: `user:john` or `search:3`. That's useful in term of creating namespaces for custom elements (e.g. comments, highlights). You can use this prefixes in [event-update](module_engine_model_markercollection-MarkerCollection.md#event-update) listeners to listen on changes in a group of markers. For instance: `model.markers.on( 'update:user', callback );` will be called whenever any `user:*` markers changes. There are two types of markers. 1. Markers managed directly, without using operations. They are added directly by [`ModelWriter`](module_engine_model_writer-ModelWriter.md) to the [`MarkerCollection`](module_engine_model_markercollection-MarkerCollection.md) without any additional mechanism. They can be used as bookmarks or visual markers. They are great for showing results of the find, or select link when the focus is in the input. 2. Markers managed using operations. These markers are also stored in [`MarkerCollection`](module_engine_model_markercollection-MarkerCollection.md) but changes in these markers is managed the same way all other changes in the model structure - using operations. Therefore, they are handled in the undo stack and synchronized between clients if the collaboration plugin is enabled. This type of markers is useful for solutions like spell checking or comments. Both type of them should be added / updated by [`addMarker`](module_engine_model_writer-ModelWriter.md#function-addMarker) and removed by [`removeMarker`](module_engine_model_writer-ModelWriter.md#function-removeMarker) methods. ```typescript model.change( ( writer ) => { const marker = writer.addMarker( name, { range, usingOperation: true } ); // ... writer.removeMarker( marker ); } ); ``` See [`ModelWriter`](module_engine_model_writer-ModelWriter.md) to find more examples. Since markers need to track change in the document, for efficiency reasons, it is best to create and keep as little markers as possible and remove them as soon as they are not needed anymore. Markers can be downcasted and upcasted. Markers downcast happens on [event-addMarker](module_engine_conversion_downcastdispatcher-DowncastDispatcher.md#event-addMarker) and [event-removeMarker](module_engine_conversion_downcastdispatcher-DowncastDispatcher.md#event-removeMarker) events. Use [downcast converters](module_engine_conversion_downcasthelpers.md) or attach a custom converter to mentioned events. For [data pipeline](module_engine_controller_datacontroller-DataController.md), marker should be downcasted to an element. Then, it can be upcasted back to a marker. Again, use [upcast converters](module_engine_conversion_upcasthelpers.md) or attach a custom converter to [event-element](module_engine_conversion_upcastdispatcher-UpcastDispatcher.md#event-element). `Marker` instances are created and destroyed only by [MarkerCollection](module_engine_model_markercollection-MarkerCollection.md). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L355) ## Properties ### `affectsData: boolean` _(readonly)_ A value indicating if the marker changes the data. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L419) ### `managedUsingOperations: boolean` _(readonly)_ A value indicating if the marker is managed using operations. See [marker class description](module_engine_model_markercollection-Marker.md) to learn more about marker types. See [`addMarker`](module_engine_model_writer-ModelWriter.md#function-addMarker). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L408) ### `name: string` _(readonly)_ Marker's name. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L359) ### `_affectsData: boolean` _(internal)_ Specifies whether the marker affects the data produced by the data pipeline (is persisted in the editor's data). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L374) ### `_managedUsingOperations: boolean` _(internal)_ Flag indicates if the marker is managed using operations or not. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L366) ### `_liveRange: ModelLiveRange | null` _(private)_ Range marked by the marker. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L379) ## Methods ### `constructor( name, liveRange, managedUsingOperations, affectsData )` Creates a marker instance. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L389) #### Parameters * `name: string` Marker name. * `liveRange: ModelLiveRange` Range marked by the marker. * `managedUsingOperations: boolean` Specifies whether the marker is managed using operations. * `affectsData: boolean` Specifies whether the marker affects the data produced by the data pipeline (is persisted in the editor's data). ### `delegate( events ) → EmitterMixinDelegateChain` _(inherited)_ Delegates selected events to another [`Emitter`](module_utils_emittermixin-Emitter.md). For instance: ```typescript emitterA.delegate( 'eventX' ).to( emitterB ); emitterA.delegate( 'eventX', 'eventY' ).to( emitterC ); ``` then `eventX` is delegated (fired by) `emitterB` and `emitterC` along with `data`: ```typescript emitterA.fire( 'eventX', data ); ``` and `eventY` is delegated (fired by) `emitterC` along with `data`: ```typescript emitterA.fire( 'eventY', data ); ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L539) #### Parameters * `events: Array` Event names that will be delegated to another emitter. #### Returns * `EmitterMixinDelegateChain` ### `fire( eventOrInfo, args ) → GetEventInfo[ 'return' ]` _(inherited)_ Fires an event, executing all callbacks registered for it. The first parameter passed to callbacks is an [`EventInfo`](module_utils_eventinfo-EventInfo.md) object, followed by the optional `args` provided in the `fire()` method call. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L512) #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `eventOrInfo: GetNameOrEventInfo` The name of the event or `EventInfo` object if event is delegated. * `args: TEvent[ 'args' ]` Additional arguments to be passed to the callbacks. #### Returns * `GetEventInfo[ 'return' ]` By default the method returns `undefined`. However, the return value can be changed by listeners through modification of the [`evt.return`](module_utils_eventinfo-EventInfo.md#member-return)'s property (the event info is the first param of every callback). ### `getData() → MarkerData` Returns the marker data (properties defining the marker). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L430) #### Returns * `MarkerData` ### `getEnd() → ModelPosition` Returns current marker end position. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L452) #### Returns * `ModelPosition` ### `getRange() → ModelRange` Returns a range that represents the current state of the marker. Keep in mind that returned value is a [Range](module_engine_model_range-ModelRange.md), not a [ModelLiveRange](module_engine_model_liverange-ModelLiveRange.md). This means that it is up-to-date and relevant only until next model document change. Do not store values returned by this method. Instead, store [`name`](#member-name) and get `Marker` instance from [MarkerCollection](module_engine_model_markercollection-MarkerCollection.md) every time there is a need to read marker properties. This will guarantee that the marker has not been removed and that it's data is up-to-date. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L470) #### Returns * `ModelRange` ### `getStart() → ModelPosition` Returns current marker start position. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L441) #### Returns * `ModelPosition` ### `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 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` ### `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` ### `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` ### `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` ### `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` ### `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` ### `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` ### `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` ### `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` ### `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` ### `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 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` ### `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` ### `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` ### `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` ### `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` ### `listenTo( emitter, event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired in a specific (emitter) object. Events can be grouped in namespaces using `:`. When namespaced event is fired, it additionally fires all callbacks for that namespace. ```typescript // 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](module_utils_eventinfo-EventInfo.md#member-stop) and set the [return value](module_utils_eventinfo-EventInfo.md#member-return) of the [`fire`](#function-fire) method. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L475) #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `emitter: Emitter` The object that fires the event. * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `off( event, callback ) → void` _(inherited)_ Stops executing the callback on the given event. Shorthand for [`this.stopListening( this, event, callback )`](#function-stopListening:BASE_STOP). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L444) #### Parameters * `event: string` The name of the event. * `callback: Function` The function to stop being called. #### Returns * `void` ### `on( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired. Shorthand for [`this.listenTo( this, event, callback, options )`](#function-listenTo:BASE_EMITTER) (it makes the emitter listen on itself). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L416) #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `once( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed on the next time the event is fired only. This is similar to calling [`on`](#function-on) followed by [`off`](#function-off) in the callback. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L431) #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `stopDelegating( event?, emitter? ) → void` _(inherited)_ Stops delegating events. It can be used at different levels: * To stop delegating all events. * To stop delegating a specific event to all emitters. * To stop delegating a specific event to a specific emitter. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L552) #### 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. #### Returns * `void` ### `stopListening( emitter?, event?, callback? ) → void` _(inherited)_ Stops listening for events. It can be used at different levels: * 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. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L497) #### 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`. #### Returns * `void` ### `toJSON() → unknown` Converts `Marker` to plain object and returns it. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L483) #### Returns * `unknown` `Marker` converted to plain object. ### `_attachLiveRange( liveRange ) → ModelLiveRange` _(internal)_ Binds new live range to the marker and detach the old one if is attached. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L499) #### Parameters * `liveRange: ModelLiveRange` Live range to attach #### Returns * `ModelLiveRange` Attached live range. ### `_detachLiveRange() → void` _(internal)_ Unbinds and destroys currently attached live range. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L518) #### Returns * `void` ## Events ### `change:content( eventInfo, range, data )` Fired whenever change on [`ModelDocument`](module_engine_model_document-ModelDocument.md) is done inside [marker range](#member-_liveRange). This is a delegated [ModelLiveRange change:content event](module_engine_model_liverange-ModelLiveRange.md#event-change:content). When marker is removed from [MarkerCollection](module_engine_model_markercollection-MarkerCollection.md), all event listeners listening to it should be removed. It is best to do it on [MarkerCollection update event](module_engine_model_markercollection-MarkerCollection.md#event-update). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L558) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `range: ModelRange` * `data: object` #### Related: * [ModelLiveRange#event:change:content](module_engine_model_liverange-ModelLiveRange.md#event-change:content) ### `change:range( eventInfo, range, data )` Fired whenever [marker range](#member-_liveRange) is changed due to changes on [`ModelDocument`](module_engine_model_document-ModelDocument.md). This is a delegated [ModelLiveRange change:range event](module_engine_model_liverange-ModelLiveRange.md#event-change:range). When marker is removed from [MarkerCollection](module_engine_model_markercollection-MarkerCollection.md), all event listeners listening to it should be removed. It is best to do it on [MarkerCollection update event](module_engine_model_markercollection-MarkerCollection.md#event-update). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/model/markercollection.ts#L545) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `range: ModelRange` * `data: object` #### Related: * [ModelLiveRange#event:change:range](module_engine_model_liverange-ModelLiveRange.md#event-change:range) --- Full index of the CKEditor 5 API reference: [llms.txt](llms.txt)