@ckeditor/ckeditor5-engine 41.4.1 → 42.0.0-alpha.0

package/src/model/differ.js

@@ -15,7 +15,7 @@ import Range from './range.js';
  * changed elements, after all changes are applied on the model document. Calculates the diff between saved
  * elements and new ones and returns a change set.
  */
-export default class Differ {
+class Differ {
     /**
      * Creates a `Differ` instance.
      *
@@ -30,18 +30,48 @@ export default class Differ {
          */
         this._changesInElement = new Map();
         /**
-         * A map that stores "element's children snapshots". A snapshot is representing children of a given element before
-         * the first change was applied on that element. Snapshot items are objects with two properties: `name`,
-         * containing the element name (or `'$text'` for a text node) and `attributes` which is a map of the node's attributes.
+         * Stores a snapshot for these model nodes that might have changed.
+         *
+         * This complements {@link ~Differ#_elementChildrenSnapshots `_elementChildrenSnapshots`}.
+         *
+         * See also {@link ~DifferSnapshot}.
+         */
+        this._elementsSnapshots = new Map();
+        /**
+         * For each element or document fragment inside which there was a change, it stores a snapshot of the child nodes list (an array
+         * of children snapshots that represent the state in the element / fragment before any change has happened).
+         *
+         * This complements {@link ~Differ#_elementsSnapshots `_elementsSnapshots`}.
+         *
+         * See also {@link ~DifferSnapshot}.
+         */
+        this._elementChildrenSnapshots = new Map();
+        /**
+         * Keeps the state for a given element, describing how the element was changed so far. It is used to evaluate the `action` property
+         * of diff items returned by {@link ~Differ#getChanges}.
+         *
+         * Possible values, in the order from the lowest priority to the highest priority:
+         *
+         * * `'refresh'` - element was refreshed,
+         * * `'rename'` - element was renamed,
+         * * `'move'` - element was moved (or, usually, removed, that is moved to the graveyard).
+         *
+         * Element that was refreshed, may change its state to `'rename'` if it was later renamed, or to `'move'` if it was removed.
+         * But the element cannot change its state from `'move'` to `'rename'`, or from `'rename'` to `'refresh'`.
+         *
+         * Only already existing elements are registered in `_elementState`. If a new element was inserted as a result of a buffered operation,
+         * it is not be registered in `_elementState`.
          */
-        this._elementSnapshots = new Map();
+        this._elementState = new Map();
         /**
          * A map that stores all changed markers.
          *
          * The keys of the map are marker names.
+         *
          * The values of the map are objects with the following properties:
-         * - `oldMarkerData`,
-         * - `newMarkerData`.
+         *
+         * * `oldMarkerData`,
+         * * `newMarkerData`.
          */
         this._changedMarkers = new Map();
         /**
@@ -84,7 +114,7 @@ export default class Differ {
         return this._changesInElement.size == 0 && this._changedMarkers.size == 0 && this._changedRoots.size == 0;
     }
     /**
-     * Buffers the given operation. An operation has to be buffered before it is executed.
+     * Buffers the given operation. **An operation has to be buffered before it is executed.**
      *
      * @param operationToBuffer An operation to buffer.
      */
@@ -133,6 +163,11 @@ export default class Differ {
                 if (!targetParentInserted) {
                     this._markInsert(operation.targetPosition.parent, operation.getMovedRangeStart().offset, operation.howMany);
                 }
+                // Remember -- operation is buffered before it is executed. So, it was not executed yet.
+                const range = Range._createFromPositionAndShift(operation.sourcePosition, operation.howMany);
+                for (const node of range.getItems({ shallow: true })) {
+                    this._setElementState(node, 'move');
+                }
                 break;
             }
             case 'rename': {
@@ -146,6 +181,7 @@ export default class Differ {
                     const markerData = marker.getData();
                     this.bufferMarkerChange(marker.name, markerData, markerData);
                 }
+                this._setElementState(operation.position.nodeAfter, 'rename');
                 break;
             }
             case 'split': {
@@ -153,6 +189,11 @@ export default class Differ {
                 // Mark that children of the split element were removed.
                 if (!this._isInInsertedElement(splitElement)) {
                     this._markRemove(splitElement, operation.splitPosition.offset, operation.howMany);
+                    // Remember -- operation is buffered before it is executed. So, it was not executed yet.
+                    const range = Range._createFromPositionAndShift(operation.splitPosition, operation.howMany);
+                    for (const node of range.getItems({ shallow: true })) {
+                        this._setElementState(node, 'move');
+                    }
                 }
                 // Mark that the new element (split copy) was inserted.
                 if (!this._isInInsertedElement(operation.insertionPosition.parent)) {
@@ -161,6 +202,7 @@ export default class Differ {
                 // If the split took the element from the graveyard, mark that the element from the graveyard was removed.
                 if (operation.graveyardPosition) {
                     this._markRemove(operation.graveyardPosition.parent, operation.graveyardPosition.offset, 1);
+                    this._setElementState(operation.graveyardPosition.nodeAfter, 'move');
                 }
                 break;
             }
@@ -173,10 +215,16 @@ export default class Differ {
                 // Mark that the merged element was inserted into graveyard.
                 const graveyardParent = operation.graveyardPosition.parent;
                 this._markInsert(graveyardParent, operation.graveyardPosition.offset, 1);
+                this._setElementState(mergedElement, 'move');
                 // Mark that children of merged element were inserted at new parent.
                 const mergedIntoElement = operation.targetPosition.parent;
                 if (!this._isInInsertedElement(mergedIntoElement)) {
                     this._markInsert(mergedIntoElement, operation.targetPosition.offset, mergedElement.maxOffset);
+                    // Remember -- operation is buffered before it is executed. So, it was not executed yet.
+                    const range = Range._createFromPositionAndShift(operation.sourcePosition, operation.howMany);
+                    for (const node of range.getItems({ shallow: true })) {
+                        this._setElementState(node, 'move');
+                    }
                 }
                 break;
             }
@@ -338,9 +386,9 @@ export default class Differ {
         }
         // Will contain returned results.
         let diffSet = [];
-        // Check all changed elements.
+        // Check all changed elements/roots.
         for (const element of this._changesInElement.keys()) {
-            // Get changes for this element and sort them.
+            // Get changes inside this element/root and sort them.
             const changes = this._changesInElement.get(element).sort((a, b) => {
                 if (a.offset === b.offset) {
                     if (a.type != b.type) {
@@ -354,31 +402,34 @@ export default class Differ {
                 return a.offset < b.offset ? -1 : 1;
             });
             // Get children of this element before any change was applied on it.
-            const snapshotChildren = this._elementSnapshots.get(element);
+            const childrenBefore = this._elementChildrenSnapshots.get(element);
             // Get snapshot of current element's children.
-            const elementChildren = _getChildrenSnapshot(element.getChildren());
-            // Generate actions basing on changes done on element.
-            const actions = _generateActionsFromChanges(snapshotChildren.length, changes);
-            let i = 0; // Iterator in `elementChildren` array -- iterates through current children of element.
-            let j = 0; // Iterator in `snapshotChildren` array -- iterates through old children of element.
+            const childrenAfter = _getChildrenSnapshots(element.getChildren());
+            // Generate diff instructions based on changes done in the element/root.
+            const diffInstructions = _generateDiffInstructionsFromChanges(childrenBefore.length, changes);
+            let i = 0; // Iterator in `childrenAfter` array -- iterates through current children of element.
+            let j = 0; // Iterator in `childrenBefore` array -- iterates through old children of element.
             // Process every action.
-            for (const action of actions) {
-                if (action === 'i') {
-                    // Generate diff item for this element and insert it into the diff set.
-                    diffSet.push(this._getInsertDiff(element, i, elementChildren[i]));
+            for (const instruction of diffInstructions) {
+                if (instruction === 'i') {
+                    const action = this._getDiffActionForNode(childrenAfter[i].node, 'insert');
+                    const childSnapshotBefore = this._elementsSnapshots.get(childrenAfter[i].node);
+                    const diffItem = this._getInsertDiff(element, i, action, childrenAfter[i], childSnapshotBefore);
+                    diffSet.push(diffItem);
                     i++;
                 }
-                else if (action === 'r') {
-                    // Generate diff item for this element and insert it into the diff set.
-                    diffSet.push(this._getRemoveDiff(element, i, snapshotChildren[j]));
+                else if (instruction === 'r') {
+                    const action = this._getDiffActionForNode(childrenBefore[j].node, 'remove');
+                    const diffItem = this._getRemoveDiff(element, i, action, childrenBefore[j]);
+                    diffSet.push(diffItem);
                     j++;
                 }
-                else if (action === 'a') {
+                else if (instruction === 'a') {
                     // Take attributes from saved and current children.
-                    const elementAttributes = elementChildren[i].attributes;
-                    const snapshotAttributes = snapshotChildren[j].attributes;
+                    const beforeAttributes = childrenBefore[j].attributes;
+                    const afterAttributes = childrenAfter[i].attributes;
                     let range;
-                    if (elementChildren[i].name == '$text') {
+                    if (childrenAfter[i].name == '$text') {
                         range = new Range(Position._createAt(element, i), Position._createAt(element, i + 1));
                     }
                     else {
@@ -387,7 +438,8 @@ export default class Differ {
                     }
                     // Generate diff items for this change (there might be multiple attributes changed and
                     // there is a single diff for each of them) and insert them into the diff set.
-                    diffSet.push(...this._getAttributesDiff(range, snapshotAttributes, elementAttributes));
+                    const diffItems = this._getAttributesDiff(range, beforeAttributes, afterAttributes);
+                    diffSet.push(...diffItems);
                     i++;
                     j++;
                 }
@@ -498,12 +550,69 @@ export default class Differ {
      */
     reset() {
         this._changesInElement.clear();
-        this._elementSnapshots.clear();
+        this._elementChildrenSnapshots.clear();
+        this._elementsSnapshots.clear();
+        this._elementState.clear();
         this._changedMarkers.clear();
         this._changedRoots.clear();
-        this._refreshedItems = new Set();
+        this._refreshedItems.clear();
+        this._cachedChanges = null;
+    }
+    /**
+     * Marks the given `item` in differ to be "refreshed". It means that the item will be marked as removed and inserted
+     * in the differ changes set, so it will be effectively re-converted when the differ changes are handled by a dispatcher.
+     *
+     * @internal
+     * @param item Item to refresh.
+     */
+    _refreshItem(item) {
+        if (this._isInInsertedElement(item.parent)) {
+            return;
+        }
+        this._markRemove(item.parent, item.startOffset, item.offsetSize);
+        this._markInsert(item.parent, item.startOffset, item.offsetSize);
+        this._refreshedItems.add(item);
+        this._setElementState(item, 'refresh');
+        const range = Range._createOn(item);
+        for (const marker of this._markerCollection.getMarkersIntersectingRange(range)) {
+            const markerData = marker.getData();
+            this.bufferMarkerChange(marker.name, markerData, markerData);
+        }
+        // Clear cache after each buffered operation as it is no longer valid.
         this._cachedChanges = null;
     }
+    /**
+     * Buffers all the data related to given root like it was all just added to the editor.
+     *
+     * Following changes are buffered:
+     *
+     * * root is attached,
+     * * all root content is inserted,
+     * * all root attributes are added,
+     * * all markers inside the root are added.
+     *
+     * @internal
+     */
+    _bufferRootLoad(root) {
+        if (!root.isAttached()) {
+            return;
+        }
+        this._bufferRootStateChange(root.rootName, true);
+        this._markInsert(root, 0, root.maxOffset);
+        // Buffering root attribute changes makes sense and is actually needed, even though we buffer root state change above.
+        // Because the root state change is buffered, the root attributes changes are not returned by the differ.
+        // But, if the root attribute is removed in the same change block, or the root is detached, then the differ results would be wrong.
+        //
+        for (const key of root.getAttributeKeys()) {
+            this._bufferRootAttributeChange(root.rootName, key, null, root.getAttribute(key));
+        }
+        for (const marker of this._markerCollection) {
+            if (marker.getRange().root == root) {
+                const markerData = marker.getData();
+                this.bufferMarkerChange(marker.name, { ...markerData, range: null }, markerData);
+            }
+        }
+    }
     /**
      * Buffers the root state change after the root was attached or detached
      */
@@ -563,60 +672,6 @@ export default class Differ {
             this._changedRoots.set(rootName, diffItem);
         }
     }
-    /**
-     * Marks the given `item` in differ to be "refreshed". It means that the item will be marked as removed and inserted
-     * in the differ changes set, so it will be effectively re-converted when the differ changes are handled by a dispatcher.
-     *
-     * @internal
-     * @param item Item to refresh.
-     */
-    _refreshItem(item) {
-        if (this._isInInsertedElement(item.parent)) {
-            return;
-        }
-        this._markRemove(item.parent, item.startOffset, item.offsetSize);
-        this._markInsert(item.parent, item.startOffset, item.offsetSize);
-        this._refreshedItems.add(item);
-        const range = Range._createOn(item);
-        for (const marker of this._markerCollection.getMarkersIntersectingRange(range)) {
-            const markerData = marker.getData();
-            this.bufferMarkerChange(marker.name, markerData, markerData);
-        }
-        // Clear cache after each buffered operation as it is no longer valid.
-        this._cachedChanges = null;
-    }
-    /**
-     * Buffers all the data related to given root like it was all just added to the editor.
-     *
-     * Following changes are buffered:
-     *
-     * * root is attached,
-     * * all root content is inserted,
-     * * all root attributes are added,
-     * * all markers inside the root are added.
-     *
-     * @internal
-     */
-    _bufferRootLoad(root) {
-        if (!root.isAttached()) {
-            return;
-        }
-        this._bufferRootStateChange(root.rootName, true);
-        this._markInsert(root, 0, root.maxOffset);
-        // Buffering root attribute changes makes sense and is actually needed, even though we buffer root state change above.
-        // Because the root state change is buffered, the root attributes changes are not returned by the differ.
-        // But, if the root attribute is removed in the same change block, or the root is detached, then the differ results would be wrong.
-        //
-        for (const key of root.getAttributeKeys()) {
-            this._bufferRootAttributeChange(root.rootName, key, null, root.getAttribute(key));
-        }
-        for (const marker of this._markerCollection) {
-            if (marker.getRange().root == root) {
-                const markerData = marker.getData();
-                this.bufferMarkerChange(marker.name, { ...markerData, range: null }, markerData);
-            }
-        }
-    }
     /**
      * Saves and handles an insert change.
      */
@@ -652,8 +707,8 @@ export default class Differ {
      * Saves and handles a model change.
      */
     _markChange(parent, changeItem) {
-        // First, make a snapshot of this parent's children (it will be made only if it was not made before).
-        this._makeSnapshot(parent);
+        // First, make a snapshot of the parent and its children (it will be made only if it was not made before).
+        this._makeSnapshots(parent);
         // Then, get all changes that already were done on the element (empty array if this is the first change).
         const changes = this._getChangesForElement(parent);
         // Then, look through all the changes, and transform them or the new change.
@@ -669,6 +724,49 @@ export default class Differ {
             }
         }
     }
+    /**
+     * Tries to set given state for given item.
+     *
+     * This method does simple validation (it sets the state only for model elements, not for text proxy nodes). It also follows state
+     * setting rules, that is, `'refresh'` cannot overwrite `'rename'`, and `'rename'` cannot overwrite `'move'`.
+     */
+    _setElementState(node, state) {
+        if (!node.is('element')) {
+            return;
+        }
+        const currentStatePriority = Differ._statesPriority.indexOf(this._elementState.get(node));
+        const newStatePriority = Differ._statesPriority.indexOf(state);
+        if (newStatePriority > currentStatePriority) {
+            this._elementState.set(node, state);
+        }
+    }
+    /**
+     * Returns a value for {@link ~DifferItemAction `action`} property for diff items returned by {@link ~Differ#getChanges}.
+     * This method aims to return `'rename'` or `'refresh'` when it should, and `diffItemType` ("default action") in all other cases.
+     *
+     * It bases on a few factors:
+     *
+     * * for text nodes, the method always returns `diffItemType`,
+     * * for newly inserted element, the method returns `diffItemType`,
+     * * if {@link ~Differ#_elementState element state} was not recorded, the method returns `diffItemType`,
+     * * if state was recorded, and it was `'move'` (default action), the method returns `diffItemType`,
+     * * finally, if state was `'refresh'` or `'rename'`, the method returns the state value.
+     */
+    _getDiffActionForNode(node, diffItemType) {
+        if (!node.is('element')) {
+            // Text node.
+            return diffItemType;
+        }
+        if (!this._elementsSnapshots.has(node)) {
+            // Newly inserted element.
+            return diffItemType;
+        }
+        const state = this._elementState.get(node);
+        if (!state || state == 'move') {
+            return diffItemType;
+        }
+        return state;
+    }
     /**
      * Gets an array of changes that have already been saved for a given element.
      */
@@ -684,11 +782,16 @@ export default class Differ {
         return changes;
     }
     /**
-     * Saves a children snapshot for a given element.
+     * Creates and saves a snapshot for all children of the given element.
      */
-    _makeSnapshot(element) {
-        if (!this._elementSnapshots.has(element)) {
-            this._elementSnapshots.set(element, _getChildrenSnapshot(element.getChildren()));
+    _makeSnapshots(element) {
+        if (this._elementChildrenSnapshots.has(element)) {
+            return;
+        }
+        const childrenSnapshots = _getChildrenSnapshots(element.getChildren());
+        this._elementChildrenSnapshots.set(element, childrenSnapshots);
+        for (const snapshot of childrenSnapshots) {
+            this._elementsSnapshots.set(snapshot.node, snapshot);
         }
     }
     /**
@@ -906,37 +1009,47 @@ export default class Differ {
      *
      * @param parent The element in which the change happened.
      * @param offset The offset at which change happened.
-     * @param elementSnapshot The snapshot of the removed element a character.
+     * @param action Further specifies what kind of action led to generating this change.
+     * @param elementSnapshot Snapshot of the inserted node after changes.
+     * @param elementSnapshotBefore Snapshot of the inserted node before changes.
      * @returns The diff item.
      */
-    _getInsertDiff(parent, offset, elementSnapshot) {
-        return {
+    _getInsertDiff(parent, offset, action, elementSnapshot, elementSnapshotBefore) {
+        const diffItem = {
             type: 'insert',
             position: Position._createAt(parent, offset),
             name: elementSnapshot.name,
             attributes: new Map(elementSnapshot.attributes),
             length: 1,
             changeCount: this._changeCount++,
-            _element: elementSnapshot.element
+            action
         };
+        if (action != 'insert' && elementSnapshotBefore) {
+            diffItem.before = {
+                name: elementSnapshotBefore.name,
+                attributes: new Map(elementSnapshotBefore.attributes)
+            };
+        }
+        return diffItem;
     }
     /**
      * Returns an object with a single remove change description.
      *
      * @param parent The element in which change happened.
      * @param offset The offset at which change happened.
-     * @param elementSnapshot The snapshot of the removed element a character.
+     * @param action Further specifies what kind of action led to generating this change.
+     * @param elementSnapshot The snapshot of the removed node before changes.
      * @returns The diff item.
      */
-    _getRemoveDiff(parent, offset, elementSnapshot) {
+    _getRemoveDiff(parent, offset, action, elementSnapshot) {
         return {
             type: 'remove',
+            action,
             position: Position._createAt(parent, offset),
             name: elementSnapshot.name,
             attributes: new Map(elementSnapshot.attributes),
             length: 1,
-            changeCount: this._changeCount++,
-            _element: elementSnapshot.element
+            changeCount: this._changeCount++
         };
     }
     /**
@@ -1016,42 +1129,51 @@ export default class Differ {
         const range = new Range(Position._createAt(parent, offset), Position._createAt(parent, offset + howMany));
         for (const item of range.getItems({ shallow: true })) {
             if (item.is('element')) {
-                this._elementSnapshots.delete(item);
                 this._changesInElement.delete(item);
                 this._removeAllNestedChanges(item, 0, item.maxOffset);
             }
         }
     }
 }
+/**
+ * Priority of the {@link ~Differ#_elementState element states}. States on higher indexes of the array can overwrite states on the lower
+ * indexes.
+ */
+Differ._statesPriority = [undefined, 'refresh', 'rename', 'move'];
+export default Differ;
+/**
+ * Returns a snapshot for the specified child node. Text node snapshots have the `name` property set to `$text`.
+ */
+function _getSingleNodeSnapshot(node) {
+    return {
+        node,
+        name: node.is('$text') ? '$text' : node.name,
+        attributes: new Map(node.getAttributes())
+    };
+}
 /**
  * Returns an array that is a copy of passed child list with the exception that text nodes are split to one or more
  * objects, each representing one character and attributes set on that character.
  */
-function _getChildrenSnapshot(children) {
-    const snapshot = [];
+function _getChildrenSnapshots(children) {
+    const snapshots = [];
     for (const child of children) {
         if (child.is('$text')) {
-            for (let i = 0; i < child.data.length; i++) {
-                snapshot.push({
-                    name: '$text',
-                    attributes: new Map(child.getAttributes())
-                });
+            for (let i = 0; i < child.data.length; ++i) {
+                snapshots.push(_getSingleNodeSnapshot(child));
             }
         }
         else {
-            snapshot.push({
-                name: child.name,
-                attributes: new Map(child.getAttributes()),
-                element: child
-            });
+            snapshots.push(_getSingleNodeSnapshot(child));
         }
     }
-    return snapshot;
+    return snapshots;
 }
 /**
- * Generates array of actions for given changes set.
- * It simulates what `diff` function does.
+ * Generates array of diff instructions for given changes set.
+ *
  * Generated actions are:
+ *
  * - 'e' for 'equal' - when item at that position did not change,
  * - 'i' for 'insert' - when item at that position was inserted,
  * - 'r' for 'remove' - when item at that position was removed,
@@ -1066,9 +1188,9 @@ function _getChildrenSnapshot(children) {
  *			type: insert, offset: 2, howMany: 2
  *			type: attribute, offset: 4, howMany: 1
  *
- * expected actions: equal (f), remove (o), equal (o), insert (x), insert (y), attribute (b), equal (A), equal (R)
+ * Expected actions: equal (f), remove (o), equal (o), insert (x), insert (y), attribute (b), equal (A), equal (R)
  *
- * steps taken by th script:
+ * Steps taken by the script:
  *
  * 1. change = "type: remove, offset: 1, howMany: 1"; offset = 0; oldChildrenHandled = 0
  *    1.1 between this change and the beginning is one not-changed node, fill with one equal action, one old child has been handled
@@ -1095,8 +1217,8 @@ function _getChildrenSnapshot(children) {
  *
  * The result actions are: equal, remove, equal, insert, insert, attribute, equal, equal.
  */
-function _generateActionsFromChanges(oldChildrenLength, changes) {
-    const actions = [];
+function _generateDiffInstructionsFromChanges(oldChildrenLength, changes) {
+    const diff = [];
     let offset = 0;
     let oldChildrenHandled = 0;
     // Go through all buffered changes.
@@ -1104,21 +1226,21 @@ function _generateActionsFromChanges(oldChildrenLength, changes) {
         // First, fill "holes" between changes with "equal" actions.
         if (change.offset > offset) {
             for (let i = 0; i < change.offset - offset; i++) {
-                actions.push('e');
+                diff.push('e');
             }
             oldChildrenHandled += change.offset - offset;
         }
         // Then, fill up actions accordingly to change type.
         if (change.type == 'insert') {
             for (let i = 0; i < change.howMany; i++) {
-                actions.push('i');
+                diff.push('i');
             }
             // The last handled offset is after inserted range.
             offset = change.offset + change.howMany;
         }
         else if (change.type == 'remove') {
             for (let i = 0; i < change.howMany; i++) {
-                actions.push('r');
+                diff.push('r');
             }
             // The last handled offset is at the position where the nodes were removed.
             offset = change.offset;
@@ -1126,7 +1248,7 @@ function _generateActionsFromChanges(oldChildrenLength, changes) {
             oldChildrenHandled += change.howMany;
         }
         else {
-            actions.push(...'a'.repeat(change.howMany).split(''));
+            diff.push(...'a'.repeat(change.howMany).split(''));
             // The last handled offset is at the position after the changed range.
             offset = change.offset + change.howMany;
             // We changed `howMany` old nodes, update `oldChildrenHandled`.
@@ -1137,13 +1259,13 @@ function _generateActionsFromChanges(oldChildrenLength, changes) {
     // has not been changed / removed at the end of their parent.
     if (oldChildrenHandled < oldChildrenLength) {
         for (let i = 0; i < oldChildrenLength - oldChildrenHandled - offset; i++) {
-            actions.push('e');
+            diff.push('e');
         }
     }
-    return actions;
+    return diff;
 }
 /**
- * Filter callback for Array.filter that filters out change entries that are in graveyard.
+ * Filter callback for `Array.filter` that filters out change entries that are in graveyard.
  */
 function _changesInGraveyardFilter(entry) {
     const posInGy = 'position' in entry && entry.position.root.rootName == '$graveyard';

package/src/model/document.d.ts

@@ -36,7 +36,7 @@ declare const Document_base: {
  * However, the document may contain multiple roots – e.g. when the editor has multiple editable areas
  * (e.g. a title and a body of a message).
  */
-export default class Document extends Document_base {
+export default class Document extends /* #__PURE__ */ Document_base {
     /**
      * The {@link module:engine/model/model~Model model} that the document is a part of.
      */

package/src/model/document.js

@@ -29,7 +29,7 @@ const graveyardName = '$graveyard';
  * However, the document may contain multiple roots – e.g. when the editor has multiple editable areas
  * (e.g. a title and a body of a message).
  */
-export default class Document extends EmitterMixin() {
+export default class Document extends /* #__PURE__ */ EmitterMixin() {
     /**
      * Creates an empty document instance with no {@link #roots} (other than
      * the {@link #graveyard graveyard root}).

package/src/model/documentselection.d.ts

@@ -39,7 +39,7 @@ declare const DocumentSelection_base: import("@ckeditor/ckeditor5-utils").Mixed<
  * If you need to represent a selection in document fragment,
  * use {@link module:engine/model/selection~Selection Selection class} instead.
  */
-export default class DocumentSelection extends DocumentSelection_base {
+export default class DocumentSelection extends /* #__PURE__ */ DocumentSelection_base {
     /**
      * Selection used internally by that class (`DocumentSelection` is a proxy to that selection).
      */

package/src/model/documentselection.js

@@ -36,7 +36,7 @@ const storePrefix = 'selection:';
  * If you need to represent a selection in document fragment,
  * use {@link module:engine/model/selection~Selection Selection class} instead.
  */
-export default class DocumentSelection extends EmitterMixin(TypeCheckable) {
+export default class DocumentSelection extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
     /**
      * Creates an empty live selection for given {@link module:engine/model/document~Document}.
      *

package/src/model/liveposition.d.ts

@@ -23,7 +23,7 @@ declare const LivePosition_base: import("@ckeditor/ckeditor5-utils").Mixed<typeo
  * have to be unbound.
  * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
  */
-export default class LivePosition extends LivePosition_base {
+export default class LivePosition extends /* #__PURE__ */ LivePosition_base {
     /**
      * Root of the position path.
      */