@ckeditor/ckeditor5-engine 44.3.0 → 45.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-engine",
-  "version": "44.3.0",
+  "version": "45.0.0-alpha.1",
   "description": "The editing engine of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -24,8 +24,8 @@
   "type": "module",
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-utils": "44.3.0",
-    "lodash-es": "4.17.21"
+    "@ckeditor/ckeditor5-utils": "45.0.0-alpha.1",
+    "es-toolkit": "1.32.0"
   },
   "author": "CKSource (http://cksource.com/)",
   "license": "SEE LICENSE IN LICENSE.md",

package/src/controller/datacontroller.js

@@ -35,6 +35,46 @@ import HtmlDataProcessor from '../dataprocessor/htmldataprocessor.js';
  * ```
  */
 export default class DataController extends /* #__PURE__ */ EmitterMixin() {
+    /**
+     * Data model.
+     */
+    model;
+    /**
+     * Mapper used for the conversion. It has no permanent bindings, because these are created while getting data and
+     * are cleared directly after the data are converted. However, the mapper is defined as a class property, because
+     * it needs to be passed to the `DowncastDispatcher` as a conversion API.
+     */
+    mapper;
+    /**
+     * Downcast dispatcher used by the {@link #get get method}. Downcast converters should be attached to it.
+     */
+    downcastDispatcher;
+    /**
+     * Upcast dispatcher used by the {@link #set set method}. Upcast converters should be attached to it.
+     */
+    upcastDispatcher;
+    /**
+     * The view document used by the data controller.
+     */
+    viewDocument;
+    /**
+     * Styles processor used during the conversion.
+     */
+    stylesProcessor;
+    /**
+     * Data processor used specifically for HTML conversion.
+     */
+    htmlProcessor;
+    /**
+     * Data processor used during the conversion.
+     * Same instance as {@link #htmlProcessor} by default. Can be replaced at run time to handle different format, e.g. XML or Markdown.
+     */
+    processor;
+    /**
+     * The view downcast writer just for data conversion purposes, i.e. to modify
+     * the {@link #viewDocument}.
+     */
+    _viewWriter;
     /**
      * Creates a data controller instance.
      *

package/src/controller/editingcontroller.js

@@ -20,6 +20,22 @@ import { tryFixingRange } from '../model/utils/selection-post-fixer.js';
  * browser-independent virtualization over the DOM elements. The editing controller also attaches default converters.
  */
 export default class EditingController extends /* #__PURE__ */ ObservableMixin() {
+    /**
+     * Editor model.
+     */
+    model;
+    /**
+     * Editing view controller.
+     */
+    view;
+    /**
+     * A mapper that describes the model-view binding.
+     */
+    mapper;
+    /**
+     * Downcast dispatcher that converts changes from the model to the {@link #view editing view}.
+     */
+    downcastDispatcher;
     /**
      * Creates an editing controller instance.
      *

package/src/conversion/conversion.js

@@ -55,14 +55,16 @@ import DowncastHelpers from './downcasthelpers.js';
  * Model attribute to view attribute and vice versa.
  */
 export default class Conversion {
+    /**
+     * Maps dispatchers group name to ConversionHelpers instances.
+     */
+    _helpers = new Map();
+    _downcast;
+    _upcast;
     /**
      * Creates a new conversion instance.
      */
     constructor(downcastDispatchers, upcastDispatchers) {
-        /**
-         * Maps dispatchers group name to ConversionHelpers instances.
-         */
-        this._helpers = new Map();
         // Define default 'downcast' & 'upcast' dispatchers groups. Those groups are always available as two-way converters needs them.
         this._downcast = toArray(downcastDispatchers);
         this._createConversionHelpers({ name: 'downcast', dispatchers: this._downcast, isDowncast: true });

package/src/conversion/conversionhelpers.js

@@ -9,6 +9,7 @@
  * Base class for conversion helpers.
  */
 export default class ConversionHelpers {
+    _dispatchers;
     /**
      * Creates a conversion helpers instance.
      */

package/src/conversion/downcastdispatcher.js

@@ -100,6 +100,16 @@ import { EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * ```
  */
 export default class DowncastDispatcher extends /* #__PURE__ */ EmitterMixin() {
+    /**
+     * A template for an interface passed by the dispatcher to the event callbacks.
+     *
+     * @internal
+     */
+    _conversionApi;
+    /**
+     * A map of already fired events for a given `ModelConsumable`.
+     */
+    _firedEventsMap;
     /**
      * Creates a downcast dispatcher instance.
      *

package/src/conversion/downcasthelpers.js

@@ -16,7 +16,7 @@ import ViewAttributeElement from '../view/attributeelement.js';
 import ConversionHelpers from './conversionhelpers.js';
 import StylesMap from '../view/stylesmap.js';
 import { CKEditorError, toArray } from '@ckeditor/ckeditor5-utils';
-import { cloneDeep } from 'lodash-es';
+import { cloneDeep } from 'es-toolkit/compat';
 /**
  * Downcast conversion helper functions.
  *

package/src/conversion/mapper.js

@@ -30,50 +30,50 @@ import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * stop the event.
  */
 export default class Mapper extends /* #__PURE__ */ EmitterMixin() {
+    /**
+     * Model element to view element mapping.
+     */
+    _modelToViewMapping = new WeakMap();
+    /**
+     * View element to model element mapping.
+     */
+    _viewToModelMapping = new WeakMap();
+    /**
+     * A map containing callbacks between view element names and functions evaluating length of view elements
+     * in model.
+     */
+    _viewToModelLengthCallbacks = new Map();
+    /**
+     * Model marker name to view elements mapping.
+     *
+     * Keys are `String`s while values are `Set`s with {@link module:engine/view/element~Element view elements}.
+     * One marker (name) can be mapped to multiple elements.
+     */
+    _markerNameToElements = new Map();
+    /**
+     * View element to model marker names mapping.
+     *
+     * This is reverse to {@link ~Mapper#_markerNameToElements} map.
+     */
+    _elementToMarkerNames = new Map();
+    /**
+     * The map of removed view elements with their current root (used for deferred unbinding).
+     */
+    _deferredBindingRemovals = new Map();
+    /**
+     * 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).
+     */
+    _unboundMarkerNames = new Set();
+    /**
+     * Manages dynamic cache for the `Mapper` to improve the performance.
+     */
+    _cache = new MapperCache();
     /**
      * Creates an instance of the mapper.
      */
     constructor() {
         super();
-        /**
-         * Model element to view element mapping.
-         */
-        this._modelToViewMapping = new WeakMap();
-        /**
-         * View element to model element mapping.
-         */
-        this._viewToModelMapping = new WeakMap();
-        /**
-         * A map containing callbacks between view element names and functions evaluating length of view elements
-         * in model.
-         */
-        this._viewToModelLengthCallbacks = new Map();
-        /**
-         * Model marker name to view elements mapping.
-         *
-         * Keys are `String`s while values are `Set`s with {@link module:engine/view/element~Element view elements}.
-         * One marker (name) can be mapped to multiple elements.
-         */
-        this._markerNameToElements = new Map();
-        /**
-         * View element to model marker names mapping.
-         *
-         * This is reverse to {@link ~Mapper#_markerNameToElements} map.
-         */
-        this._elementToMarkerNames = new Map();
-        /**
-         * The map of removed view elements with their current root (used for deferred unbinding).
-         */
-        this._deferredBindingRemovals = new Map();
-        /**
-         * 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).
-         */
-        this._unboundMarkerNames = new Set();
-        /**
-         * Manages dynamic cache for the `Mapper` to improve the performance.
-         */
-        this._cache = new MapperCache();
         // Default mapper algorithm for mapping model position to view position.
         this.on('modelToViewPosition', (evt, data) => {
             if (data.viewPosition) {
@@ -650,62 +650,59 @@ export default class Mapper extends /* #__PURE__ */ EmitterMixin() {
  * @internal
  */
 export class MapperCache extends /* #__PURE__ */ EmitterMixin() {
-    constructor() {
-        super(...arguments);
-        /**
-         * For every view element or document fragment tracked by `MapperCache`, it holds currently cached data, or more precisely,
-         * model offset to view position mappings. See also `MappingCache` and `CacheItem`.
-         *
-         * If an item is tracked by `MapperCache` it has an entry in this structure, so this structure can be used to check which items
-         * are tracked by `MapperCache`. When an item is no longer tracked, it is removed from this structure.
-         *
-         * Although `MappingCache` and `CacheItem` structures allows for caching any model offsets and view positions, we only cache
-         * values for model offsets that are after a view node. So, in essence, positions inside text nodes are not cached. However, it takes
-         * from one to at most a few steps, to get from a cached position to a position that is inside a view text node.
-         *
-         * Additionally, only one item per `modelOffset` is cached. There can be several view nodes that "end" at the same `modelOffset`.
-         * In this case, we favour positions that are closer to the mapped item. For example
-         *
-         * * for model: `<paragraph>Some <$text bold=true italic=true>formatted</$text> text.</paragraph>`,
-         * * and view: `<p>Some <em><strong>formatted</strong></em> text.</p>`,
-         *
-         * for model offset `14` (after "d"), we store view position after `<em>` element (i.e. view position: at `<p>`, offset `2`).
-         */
-        this._cachedMapping = new WeakMap();
-        /**
-         * When `MapperCache` {@link ~MapperCache#save saves} view position -> model offset mapping, a `CacheItem` is inserted into certain
-         * `MappingCache#cacheList` at some index. Additionally, we store that index with the view node that is before the cached view position.
-         *
-         * This allows to quickly get a cache list item related to certain view node, and hence, for fast cache invalidation.
-         *
-         * For example, consider view: `<p>Some <strong>bold</strong> text.</p>`, where `<p>` is a view element tracked by `MapperCache`.
-         * If all `<p>` children were visited by `MapperCache`, then `<p>` cache list would have four items, related to following model offsets:
-         * `0`, `5`, `9`, `15`. Then, view node `"Some "` would have index `1`, `<strong>` index `2`, and `" text." index `3`.
-         *
-         * Note that the index related with a node is always greater than `0`. The first item in cache list is always for model offset `0`
-         * (and view offset `0`), and it is not related to any node.
-         */
-        this._nodeToCacheListIndex = new WeakMap();
-        /**
-         * Callback fired whenever there is a direct or indirect children change in tracked view element or tracked view document fragment.
-         *
-         * This is specified as a property to make it easier to set as an event callback and to later turn off that event.
-         */
-        this._invalidateOnChildrenChangeCallback = (evt, viewNode, data) => {
-            // View element or document fragment changed its children at `data.index`. Clear all cache starting from before that index.
-            this._clearCacheInsideParent(viewNode, data.index);
-        };
-        /**
-         * Callback fired whenever a view text node directly or indirectly inside a tracked view element or tracked view document fragment
-         * changes its text data.
-         *
-         * This is specified as a property to make it easier to set as an event callback and to later turn off that event.
-         */
-        this._invalidateOnTextChangeCallback = (evt, viewNode) => {
-            // Text node has changed. Clear all the cache starting from before this text node.
-            this._clearCacheStartingBefore(viewNode);
-        };
-    }
+    /**
+     * For every view element or document fragment tracked by `MapperCache`, it holds currently cached data, or more precisely,
+     * model offset to view position mappings. See also `MappingCache` and `CacheItem`.
+     *
+     * If an item is tracked by `MapperCache` it has an entry in this structure, so this structure can be used to check which items
+     * are tracked by `MapperCache`. When an item is no longer tracked, it is removed from this structure.
+     *
+     * Although `MappingCache` and `CacheItem` structures allows for caching any model offsets and view positions, we only cache
+     * values for model offsets that are after a view node. So, in essence, positions inside text nodes are not cached. However, it takes
+     * from one to at most a few steps, to get from a cached position to a position that is inside a view text node.
+     *
+     * Additionally, only one item per `modelOffset` is cached. There can be several view nodes that "end" at the same `modelOffset`.
+     * In this case, we favour positions that are closer to the mapped item. For example
+     *
+     * * for model: `<paragraph>Some <$text bold=true italic=true>formatted</$text> text.</paragraph>`,
+     * * and view: `<p>Some <em><strong>formatted</strong></em> text.</p>`,
+     *
+     * for model offset `14` (after "d"), we store view position after `<em>` element (i.e. view position: at `<p>`, offset `2`).
+     */
+    _cachedMapping = new WeakMap();
+    /**
+     * When `MapperCache` {@link ~MapperCache#save saves} view position -> model offset mapping, a `CacheItem` is inserted into certain
+     * `MappingCache#cacheList` at some index. Additionally, we store that index with the view node that is before the cached view position.
+     *
+     * This allows to quickly get a cache list item related to certain view node, and hence, for fast cache invalidation.
+     *
+     * For example, consider view: `<p>Some <strong>bold</strong> text.</p>`, where `<p>` is a view element tracked by `MapperCache`.
+     * If all `<p>` children were visited by `MapperCache`, then `<p>` cache list would have four items, related to following model offsets:
+     * `0`, `5`, `9`, `15`. Then, view node `"Some "` would have index `1`, `<strong>` index `2`, and `" text." index `3`.
+     *
+     * Note that the index related with a node is always greater than `0`. The first item in cache list is always for model offset `0`
+     * (and view offset `0`), and it is not related to any node.
+     */
+    _nodeToCacheListIndex = new WeakMap();
+    /**
+     * Callback fired whenever there is a direct or indirect children change in tracked view element or tracked view document fragment.
+     *
+     * This is specified as a property to make it easier to set as an event callback and to later turn off that event.
+     */
+    _invalidateOnChildrenChangeCallback = (evt, viewNode, data) => {
+        // View element or document fragment changed its children at `data.index`. Clear all cache starting from before that index.
+        this._clearCacheInsideParent(viewNode, data.index);
+    };
+    /**
+     * Callback fired whenever a view text node directly or indirectly inside a tracked view element or tracked view document fragment
+     * changes its text data.
+     *
+     * This is specified as a property to make it easier to set as an event callback and to later turn off that event.
+     */
+    _invalidateOnTextChangeCallback = (evt, viewNode) => {
+        // Text node has changed. Clear all the cache starting from before this text node.
+        this._clearCacheStartingBefore(viewNode);
+    };
     /**
      * Saves cache for given view position mapping <-> model offset mapping. The view position should be after a node (i.e. it cannot
      * be the first position inside its parent, or in other words, `viewOffset` must be greater than `0`).

package/src/conversion/modelconsumable.js

@@ -88,21 +88,19 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * ```
  */
 export default class ModelConsumable {
-    constructor() {
-        /**
-         * Contains list of consumable values.
-         */
-        this._consumable = new Map();
-        /**
-         * For each {@link module:engine/model/textproxy~TextProxy} added to `ModelConsumable`, this registry holds a parent
-         * of that `TextProxy` and the start and end indices of that `TextProxy`. This allows identification of the `TextProxy`
-         * instances that point to the same part of the model but are different instances. Each distinct `TextProxy`
-         * is given a unique `Symbol` which is then registered as consumable. This process is transparent for the `ModelConsumable`
-         * API user because whenever `TextProxy` is added, tested, consumed or reverted, the internal mechanisms of
-         * `ModelConsumable` translate `TextProxy` to that unique `Symbol`.
-         */
-        this._textProxyRegistry = new Map();
-    }
+    /**
+     * Contains list of consumable values.
+     */
+    _consumable = new Map();
+    /**
+     * For each {@link module:engine/model/textproxy~TextProxy} added to `ModelConsumable`, this registry holds a parent
+     * of that `TextProxy` and the start and end indices of that `TextProxy`. This allows identification of the `TextProxy`
+     * instances that point to the same part of the model but are different instances. Each distinct `TextProxy`
+     * is given a unique `Symbol` which is then registered as consumable. This process is transparent for the `ModelConsumable`
+     * API user because whenever `TextProxy` is added, tested, consumed or reverted, the internal mechanisms of
+     * `ModelConsumable` translate `TextProxy` to that unique `Symbol`.
+     */
+    _textProxyRegistry = new Map();
     /**
      * Adds a consumable value to the consumables list and links it with a given model item.
      *

package/src/conversion/upcastdispatcher.js

@@ -108,6 +108,34 @@ import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * @fires documentFragment
  */
 export default class UpcastDispatcher extends /* #__PURE__ */ EmitterMixin() {
+    /**
+     * An interface passed by the dispatcher to the event callbacks.
+     */
+    conversionApi;
+    /**
+     * The list of elements that were created during splitting.
+     *
+     * After the conversion process, the list is cleared.
+     */
+    _splitParts = new Map();
+    /**
+     * The list of cursor parent elements that were created during splitting.
+     *
+     * After the conversion process the list is cleared.
+     */
+    _cursorParents = new Map();
+    /**
+     * The position in the temporary structure where the converted content is inserted. The structure reflects the context of
+     * the target position where the content will be inserted. This property is built based on the context parameter of the
+     * convert method.
+     */
+    _modelCursor = null;
+    /**
+     * The list of elements that were created during the splitting but should not get removed on conversion end even if they are empty.
+     *
+     * The list is cleared after the conversion process.
+     */
+    _emptyElementsToKeep = new Set();
     /**
      * Creates an upcast dispatcher that operates using the passed API.
      *
@@ -117,30 +145,6 @@ export default class UpcastDispatcher extends /* #__PURE__ */ EmitterMixin() {
      */
     constructor(conversionApi) {
         super();
-        /**
-         * The list of elements that were created during splitting.
-         *
-         * After the conversion process, the list is cleared.
-         */
-        this._splitParts = new Map();
-        /**
-         * The list of cursor parent elements that were created during splitting.
-         *
-         * After the conversion process the list is cleared.
-         */
-        this._cursorParents = new Map();
-        /**
-         * The position in the temporary structure where the converted content is inserted. The structure reflects the context of
-         * the target position where the content will be inserted. This property is built based on the context parameter of the
-         * convert method.
-         */
-        this._modelCursor = null;
-        /**
-         * The list of elements that were created during the splitting but should not get removed on conversion end even if they are empty.
-         *
-         * The list is cleared after the conversion process.
-         */
-        this._emptyElementsToKeep = new Set();
         this.conversionApi = {
             ...conversionApi,
             consumable: null,

package/src/conversion/upcasthelpers.d.ts

@@ -314,7 +314,7 @@ export default class UpcastHelpers extends ConversionHelpers<UpcastDispatcher> {
         };
         model: string | {
             key: string;
-            value: unknown | ((viewElement: ViewElement, conversionApi: UpcastConversionApi) => unknown);
+            value: unknown | ((viewElement: ViewElement, conversionApi: UpcastConversionApi, data: UpcastConversionData<ViewElement>) => unknown);
             name?: string;
         };
         converterPriority?: PriorityString;

package/src/conversion/upcasthelpers.js

@@ -6,7 +6,7 @@ import Matcher from '../view/matcher.js';
 import ConversionHelpers from './conversionhelpers.js';
 import { isParagraphable, wrapInParagraph } from '../model/utils/autoparagraphing.js';
 import { priorities } from '@ckeditor/ckeditor5-utils';
-import { cloneDeep } from 'lodash-es';
+import { cloneDeep } from 'es-toolkit/compat';
 /**
  * Contains the {@link module:engine/view/view view} to {@link module:engine/model/model model} converters for
  * {@link module:engine/conversion/upcastdispatcher~UpcastDispatcher}.
@@ -842,7 +842,7 @@ function prepareToAttributeConverter(config, shallow) {
         }
         const modelKey = config.model.key;
         const modelValue = typeof config.model.value == 'function' ?
-            config.model.value(data.viewItem, conversionApi) : config.model.value;
+            config.model.value(data.viewItem, conversionApi, data) : config.model.value;
         // Do not convert if attribute building function returned falsy value.
         if (modelValue === null) {
             return;

package/src/conversion/viewconsumable.js

@@ -32,15 +32,13 @@ import { CKEditorError } from '@ckeditor/ckeditor5-utils';
  * ```
  */
 export default class ViewConsumable {
-    constructor() {
-        /**
-         * Map of consumable elements. If {@link module:engine/view/element~Element element} is used as a key,
-         * {@link module:engine/conversion/viewconsumable~ViewElementConsumables ViewElementConsumables} instance is stored as value.
-         * For {@link module:engine/view/text~Text text nodes} and
-         * {@link module:engine/view/documentfragment~DocumentFragment document fragments} boolean value is stored as value.
-         */
-        this._consumables = new Map();
-    }
+    /**
+     * Map of consumable elements. If {@link module:engine/view/element~Element element} is used as a key,
+     * {@link module:engine/conversion/viewconsumable~ViewElementConsumables ViewElementConsumables} instance is stored as value.
+     * For {@link module:engine/view/text~Text text nodes} and
+     * {@link module:engine/view/documentfragment~DocumentFragment document fragments} boolean value is stored as value.
+     */
+    _consumables = new Map();
     /**
      * Adds view {@link module:engine/view/element~Element element}, {@link module:engine/view/text~Text text node} or
      * {@link module:engine/view/documentfragment~DocumentFragment document fragment} as ready to be consumed.
@@ -252,23 +250,24 @@ export default class ViewConsumable {
  * It represents and manipulates consumable parts of a single {@link module:engine/view/element~Element}.
  */
 export class ViewElementConsumables {
+    element;
+    /**
+     * Flag indicating if name of the element can be consumed.
+     */
+    _canConsumeName = null;
+    /**
+     * A map of element's consumables.
+     * * For plain attributes the value is a boolean indicating whether the attribute is available to consume.
+     * * For token based attributes (like class list and style) the value is a map of tokens to booleans
+     * indicating whether the token is available to consume on the given attribute.
+     */
+    _attributes = new Map();
     /**
      * Creates ViewElementConsumables instance.
      *
      * @param from View element from which `ViewElementConsumables` is being created.
      */
     constructor(from) {
-        /**
-         * Flag indicating if name of the element can be consumed.
-         */
-        this._canConsumeName = null;
-        /**
-         * A map of element's consumables.
-         * * For plain attributes the value is a boolean indicating whether the attribute is available to consume.
-         * * For token based attributes (like class list and style) the value is a map of tokens to booleans
-         * indicating whether the token is available to consume on the given attribute.
-         */
-        this._attributes = new Map();
         this.element = from;
     }
     /**

package/src/dataprocessor/htmldataprocessor.js

@@ -13,13 +13,25 @@ import DomConverter from '../view/domconverter.js';
  * This data processor implementation uses HTML as input and output data.
  */
 export default class HtmlDataProcessor {
+    /**
+     * A DOM parser instance used to parse an HTML string to an HTML document.
+     */
+    domParser;
+    /**
+     * A DOM converter used to convert DOM elements to view elements.
+     */
+    domConverter;
+    /**
+     * A basic HTML writer instance used to convert DOM elements to an HTML string.
+     */
+    htmlWriter;
+    skipComments = true;
     /**
      * Creates a new instance of the HTML data processor class.
      *
      * @param document The view document instance.
      */
     constructor(document) {
-        this.skipComments = true;
         this.domParser = new DOMParser();
         this.domConverter = new DomConverter(document, { renderingMode: 'data' });
         this.htmlWriter = new BasicHtmlWriter();

package/src/dataprocessor/xmldataprocessor.js

@@ -15,6 +15,27 @@ import DomConverter from '../view/domconverter.js';
  * For example, `<link>Text</link>` is a valid XML but invalid HTML.
  */
 export default class XmlDataProcessor {
+    /**
+     * A list of namespaces allowed to use in the XML input.
+     *
+     * For example, registering namespaces [ 'attribute', 'container' ] allows to use `<attirbute:tagName></attribute:tagName>`
+     * and `<container:tagName></container:tagName>` input. It is mainly for debugging.
+     */
+    namespaces;
+    /**
+     * DOM parser instance used to parse an XML string to an XML document.
+     */
+    domParser;
+    /**
+     * DOM converter used to convert DOM elements to view elements.
+     */
+    domConverter;
+    /**
+     * A basic HTML writer instance used to convert DOM elements to an XML string.
+     * There is no need to use a dedicated XML writer because the basic HTML writer works well in this case.
+     */
+    htmlWriter;
+    skipComments = true;
     /**
      * Creates a new instance of the XML data processor class.
      *
@@ -23,7 +44,6 @@ export default class XmlDataProcessor {
      * @param options.namespaces A list of namespaces allowed to use in the XML input.
      */
     constructor(document, options = {}) {
-        this.skipComments = true;
         this.namespaces = options.namespaces || [];
         this.domParser = new DOMParser();
         this.domConverter = new DomConverter(document, { renderingMode: 'data' });

package/src/dev-utils/model.js

@@ -25,7 +25,7 @@ import { StylesProcessor } from '../view/stylesmap.js';
 import DowncastDispatcher from '../conversion/downcastdispatcher.js';
 import UpcastDispatcher from '../conversion/upcastdispatcher.js';
 import { toMap } from '@ckeditor/ckeditor5-utils';
-import { isPlainObject } from 'lodash-es';
+import { isPlainObject } from 'es-toolkit/compat';
 /**
  * Writes the content of a model {@link module:engine/model/document~Document document} to an HTML-like string.
  *

package/src/dev-utils/operationreplayer.js

@@ -11,6 +11,9 @@ import OperationFactory from '../model/operation/operationfactory.js';
  * Operation replayer is a development tool created for easy replaying of operations on the document from stringified operations.
  */
 export default class OperationReplayer {
+    _model;
+    _logSeparator;
+    _operationsToReplay;
     /**
      * @param model Data model.
      * @param logSeparator Separator between operations.