@ckeditor/ckeditor5-engine 45.2.1-alpha.10 → 45.2.1-alpha.2

package/dist/index.js

@@ -15770,7 +15770,7 @@ Range.prototype.is = function(type) {
  * * it is an internal tool, used by `Mapper`, transparent to the outside (no additional effort when developing a plugin or a converter),
  * * it stores all the necessary data internally, which makes it easier to disable or debug,
  * * it is optimized for initial downcast process (long insertions), which is crucial for editor init and data save,
- * * it does not save all possible positions mapping for memory considerations, although it is a possible improvement, which may increase
+ * * it does not save all possible positions for memory considerations, although it is a possible improvement, which may have increase
  *   performance, as well as simplify some parts of the `MapperCache` logic.
  *
  * @internal
@@ -15786,8 +15786,13 @@ Range.prototype.is = function(type) {
 	 * 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 positions that map to the same `modelOffset`.
-	 * Only the first save for `modelOffset` is stored.
+	 * 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
@@ -15816,22 +15821,13 @@ Range.prototype.is = function(type) {
 	 *
 	 * 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)=>{
-        // It is enough to validate starting from "after the text node", because the first cache entry that we might want to invalidate
-        // is the position after this text node.
-        //
-        // For example - assume following view and following view positions cached (marked by `^`): `<p>Foo^<strong>bar^</strong>^abc^</p>`.
-        //
-        // If we change text "bar", we only need to invalidate cached positions after it. Cached positions before the text are not changed.
-        //
-        this._clearCacheAfter(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`).
 	 *
-	 * Note, that if `modelOffset` for given `viewContainer` was already saved, the stored view position (i.e. parent+offset) will not
-	 * be overwritten. However, it is important to still save it, as we still store additional data related to cached view positions.
-	 *
 	 * @param viewParent View position parent.
 	 * @param viewOffset View position offset. Must be greater than `0`.
 	 * @param viewContainer Tracked view position ascendant (it may be the direct parent of the view position).
@@ -15843,18 +15839,23 @@ Range.prototype.is = function(type) {
         const cacheItem = cache.cacheMap.get(modelOffset);
         if (cacheItem) {
             // We already cached this offset. Don't overwrite the cache.
-            // However, we still need to set a proper entry in `_nodeToCacheListIndex`. We can figure it out based on existing `cacheItem`.
             //
+            // This assumes that `Mapper` works in a way that we first cache the parent and only then cache children, as we prefer position
+            // after the parent ("closer" to the tracked ancestor). It might be safer to check which position is preferred (newly saved or
+            // the one currently in cache) but it would require additional processing. For now, `Mapper#_findPositionIn()` and
+            // `Mapper#getModelLength()` are implemented so that parents are cached before their children.
+            //
+            // So, don't create new cache if one already exists. Instead, only save `_nodeToCacheListIndex` value for the related view node.
+            const viewChild = viewParent.getChild(viewOffset - 1);
+            // Figure out what index to save with `viewChild`.
             // We have a `cacheItem` for the `modelOffset`, so we can get a `viewPosition` from there. Before that view position, there
             // must be a node. That node must have an index set. This will be the index we will want to use.
             // Since we expect `viewOffset` to be greater than 0, then in almost all cases `modelOffset` will be greater than 0 as well.
             // As a result, we can expect `cacheItem.viewPosition.nodeBefore` to be set.
             //
             // However, in an edge case, were the tracked element contains a 0-model-length view element as the first child (UI element or
-            // an empty attribute element), then `modelOffset` will be 0, and `cacheItem.viewPosition` will be before any view node.
-            // In such edge case, `cacheItem.viewPosition.nodeBefore` is `undefined`, so we set index to `0`.
-            //
-            const viewChild = viewParent.getChild(viewOffset - 1);
+            // an empty attribute element), then `modelOffset` will be 0, and `cacheItem` will be the first cache item, which is before any
+            // view node. In such edge case, `cacheItem.viewPosition.nodeBefore` is undefined, and we manually set to `0`.
             const index = cacheItem.viewPosition.nodeBefore ? this._nodeToCacheListIndex.get(cacheItem.viewPosition.nodeBefore) : 0;
             this._nodeToCacheListIndex.set(viewChild, index);
             return;
@@ -15983,9 +15984,6 @@ Range.prototype.is = function(type) {
     }
     /**
 	 * Invalidates cache inside `viewParent`, starting from given `index` in that parent.
-	 *
-	 * This method may clear a bit more cache than just what was saved after given `index`, but it is guaranteed that at least it
-	 * will invalidate everything after `index`.
 	 */ _clearCacheInsideParent(viewParent, index) {
         if (index == 0) {
             // Change at the beginning of the parent.
@@ -15994,22 +15992,28 @@ Range.prototype.is = function(type) {
                 this._clearCacheAll(viewParent);
             } else {
                 // If this is not a tracked element, remove cache starting from before this element.
-                // Since it is not a tracked element, it has to have a parent.
-                this._clearCacheInsideParent(viewParent.parent, viewParent.index);
+                this._clearCacheStartingBefore(viewParent);
             }
         } else {
             // Change in the middle of the parent. Get a view node that's before the change.
             const lastValidNode = viewParent.getChild(index - 1);
-            // Then, clear all cache after this view node.
+            // Then, clear all cache starting from before this view node.
             //
-            this._clearCacheAfter(lastValidNode);
+            // Possible performance improvement. We could have had `_clearCacheAfter( lastValidNode )` instead.
+            // If the `lastValidNode` is the last unchanged node, then we could clear everything AFTER it, not before.
+            // However, with the current setup, it didn't work properly and the actual gain wasn't that big on the tested data.
+            // The problem was with following example: <p>Foo<em><strong>Xyz</strong></em>Bar</p>.
+            // In this example we cache position after <em>, i.e. view position `<p>` 2 is saved with model offset 6.
+            // Now, if we add some text in `<em>`, we won't validate this cached item even though it gets outdated.
+            // So, if there's a need to have `_clearCacheAfter()`, we need to solve the above case first.
+            //
+            this._clearCacheStartingBefore(lastValidNode);
         }
     }
     /**
 	 * Clears all the cache for given tracked `viewContainer`.
 	 */ _clearCacheAll(viewContainer) {
         const cache = this._cachedMapping.get(viewContainer);
-        // TODO: Should clear `_nodeToCacheListIndex` too?
         if (cache.maxModelOffset > 0) {
             cache.maxModelOffset = 0;
             cache.cacheList.length = 1;
@@ -16018,45 +16022,44 @@ Range.prototype.is = function(type) {
         }
     }
     /**
-	 * Clears all the stored cache that is after given `viewNode`. The `viewNode` can be any node that is inside a tracked view element
+	 * Clears all the stored cache starting before given `viewNode`. The `viewNode` can be any node that is inside a tracked view element
 	 * or view document fragment.
-	 *
-	 * In reality, this function may clear a bit more cache than just "starting after" `viewNode`, but it is guaranteed that at least
-	 * all cache after `viewNode` is invalidated.
-	 */ _clearCacheAfter(viewNode) {
+	 */ _clearCacheStartingBefore(viewNode) {
         // To quickly invalidate the cache, we base on the cache list index stored with the node. See docs for `this._nodeToCacheListIndex`.
         const cacheListIndex = this._nodeToCacheListIndex.get(viewNode);
         // If there is no index stored, it means that this `viewNode` has not been cached yet.
         if (cacheListIndex === undefined) {
-            // If the node is not cached, maybe it's parent is. We will try to invalidate the cache using the parent.
+            // If the node is not cached, maybe it's parent is. We will try to invalidate the cache starting from before the parent.
+            // Note, that there always must be a parent if we got here.
             const viewParent = viewNode.parent;
-            // If the parent is a non-tracked element, try clearing the cache starting from the position before it.
+            // If the parent is a non-tracked element, try clearing the cache starting before it.
             //
-            // For example: `<p>Abc<strong>def<em>ghi</em></strong></p>`.
-            //
-            // If `viewNode` is `<em>` in this case, and it was not cached yet, we will try to clear cache starting from before `<strong>`.
+            // This situation may happen e.g. if structure like `<p><strong><em>Foo</em></strong>...` was stepped over in
+            // `Mapper#_findPositionIn()` and the children are not cached yet, but the `<strong>` element is. If something changes
+            // inside this structure, make sure to invalidate all the cache after `<strong>`.
             //
             // If the parent is a tracked element, then it means there's no cache to clear (nothing after the element is cached).
-            // In this case, there's nothing to do. We assume that there are no "holes" in caching in direct children of tracked element
-            // (that is if some children is cached, then its previous sibling is cached too, and we would not end up inside this `if`).
-            //
-            // TODO: Most probably this `if` could be removed altogether, after recent changes in Mapper.
-            // TODO: Now we cache all items one after another, so there aren't any "holes" anywhere, not only on top-level.
+            // In this case, there's nothing to do.
             //
             if (!this._cachedMapping.has(viewParent)) {
-                this._clearCacheInsideParent(viewParent.parent, viewParent.index);
+                this._clearCacheStartingBefore(viewParent);
             }
             return;
         }
+        // Note: there was a consideration to save the `viewContainer` value together with `cacheListIndex` value.
+        // However, it is like it is on purpose. We want to find *current* mapped ancestor for the `viewNode`.
+        // This is an essential step to verify if the cache is still up-to-date.
+        // Actually, we could save `viewContainer` and compare it to current tracked ancestor to quickly invalidate.
+        // But this kinda happens with our flow and other assumptions around caching list index anyway.
         let viewContainer = viewNode.parent;
         while(!this._cachedMapping.has(viewContainer)){
             viewContainer = viewContainer.parent;
         }
-        this._clearCacheFromCacheIndex(viewContainer, cacheListIndex);
+        this._clearCacheFromIndex(viewContainer, cacheListIndex);
     }
     /**
 	 * Clears all the cache in the cache list related to given `viewContainer`, starting from `index` (inclusive).
-	 */ _clearCacheFromCacheIndex(viewContainer, index) {
+	 */ _clearCacheFromIndex(viewContainer, index) {
         if (index === 0) {
             // Don't remove the first entry in the cache (this entry is always a mapping between view offset 0 <-> model offset 0,
             // and it is a default value that is always expected to be in the cache list).
@@ -22839,6 +22842,251 @@ function getFromAttributeCreator(config) {
     };
 }
 
+/**
+ * Injects selection post-fixer to the model.
+ *
+ * The role of the selection post-fixer is to ensure that the selection is in a correct place
+ * after a {@link module:engine/model/model~Model#change `change()`} block was executed.
+ *
+ * The correct position means that:
+ *
+ * * All collapsed selection ranges are in a place where the {@link module:engine/model/schema~Schema}
+ * allows a `$text`.
+ * * None of the selection's non-collapsed ranges crosses a {@link module:engine/model/schema~Schema#isLimit limit element}
+ * boundary (a range must be rooted within one limit element).
+ * * Only {@link module:engine/model/schema~Schema#isSelectable selectable elements} can be selected from the outside
+ * (e.g. `[<paragraph>foo</paragraph>]` is invalid). This rule applies independently to both selection ends, so this
+ * selection is correct: `<paragraph>f[oo</paragraph><imageBlock></imageBlock>]`.
+ *
+ * If the position is not correct, the post-fixer will automatically correct it.
+ *
+ * ## Fixing a non-collapsed selection
+ *
+ * See as an example a selection that starts in a P1 element and ends inside the text of a TD element
+ * (`[` and `]` are range boundaries and `(l)` denotes an element defined as `isLimit=true`):
+ *
+ * ```
+ * root
+ *  |- element P1
+ *  |   |- "foo"                                      root
+ *  |- element TABLE (l)                   P1         TABLE             P2
+ *  |   |- element TR (l)                 f o[o     TR      TR         b a r
+ *  |   |   |- element TD (l)                       TD      TD
+ *  |   |       |- "aaa"                          a]a a    b b b
+ *  |   |- element TR (l)
+ *  |   |   |- element TD (l)                           ||
+ *  |   |       |- "bbb"                                ||
+ *  |- element P2                                       VV
+ *  |   |- "bar"
+ *                                                    root
+ *                                         P1         TABLE]            P2
+ *                                        f o[o     TR      TR         b a r
+ *                                                  TD      TD
+ *                                                a a a    b b b
+ * ```
+ *
+ * In the example above, the TABLE, TR and TD are defined as `isLimit=true` in the schema. The range which is not contained within
+ * a single limit element must be expanded to select the outermost limit element. The range end is inside the text node of the TD element.
+ * As the TD element is a child of the TR and TABLE elements, where both are defined as `isLimit=true` in the schema, the range must be
+ * expanded to select the whole TABLE element.
+ *
+ * **Note** If the selection contains multiple ranges, the method returns a minimal set of ranges that are not intersecting after expanding
+ * them to select `isLimit=true` elements.
+ */ function injectSelectionPostFixer(model) {
+    model.document.registerPostFixer((writer)=>selectionPostFixer(writer, model));
+}
+/**
+ * The selection post-fixer.
+ */ function selectionPostFixer(writer, model) {
+    const selection = model.document.selection;
+    const schema = model.schema;
+    const ranges = [];
+    let wasFixed = false;
+    for (const modelRange of selection.getRanges()){
+        // Go through all ranges in selection and try fixing each of them.
+        // Those ranges might overlap but will be corrected later.
+        const correctedRange = tryFixingRange(modelRange, schema);
+        // "Selection fixing" algorithms sometimes get lost. In consequence, it may happen
+        // that a new range is returned but, in fact, it has the same positions as the original
+        // range anyway. If this range is not discarded, a new selection will be set and that,
+        // for instance, would destroy the selection attributes. Let's make sure that the post-fixer
+        // actually worked first before setting a new selection.
+        //
+        // https://github.com/ckeditor/ckeditor5/issues/6693
+        if (correctedRange && !correctedRange.isEqual(modelRange)) {
+            ranges.push(correctedRange);
+            wasFixed = true;
+        } else {
+            ranges.push(modelRange);
+        }
+    }
+    // If any of ranges were corrected update the selection.
+    if (wasFixed) {
+        writer.setSelection(mergeIntersectingRanges(ranges), {
+            backward: selection.isBackward
+        });
+    }
+    return false;
+}
+/**
+ * Tries fixing a range if it's incorrect.
+ *
+ * **Note:** This helper is used by the selection post-fixer and to fix the `beforeinput` target ranges.
+ *
+ * @returns Returns fixed range or null if range is valid.
+ */ function tryFixingRange(range, schema) {
+    if (range.isCollapsed) {
+        return tryFixingCollapsedRange(range, schema);
+    }
+    return tryFixingNonCollapsedRage(range, schema);
+}
+/**
+ * Tries to fix collapsed ranges.
+ *
+ * * Fixes situation when a range is in a place where $text is not allowed
+ *
+ * @param range Collapsed range to fix.
+ * @returns Returns fixed range or null if range is valid.
+ */ function tryFixingCollapsedRange(range, schema) {
+    const originalPosition = range.start;
+    const nearestSelectionRange = schema.getNearestSelectionRange(originalPosition);
+    // This might be null, i.e. when the editor data is empty or the selection is inside a limit element
+    // that doesn't allow text inside.
+    // In the first case, there is no need to fix the selection range.
+    // In the second, let's go up to the outer selectable element
+    if (!nearestSelectionRange) {
+        const ancestorObject = originalPosition.getAncestors().reverse().find((item)=>schema.isObject(item));
+        if (ancestorObject) {
+            return Range._createOn(ancestorObject);
+        }
+        return null;
+    }
+    if (!nearestSelectionRange.isCollapsed) {
+        return nearestSelectionRange;
+    }
+    const fixedPosition = nearestSelectionRange.start;
+    // Fixed position is the same as original - no need to return corrected range.
+    if (originalPosition.isEqual(fixedPosition)) {
+        return null;
+    }
+    return new Range(fixedPosition);
+}
+/**
+ * Tries to fix an expanded range.
+ *
+ * @param range Expanded range to fix.
+ * @returns Returns fixed range or null if range is valid.
+ */ function tryFixingNonCollapsedRage(range, schema) {
+    const { start, end } = range;
+    const isTextAllowedOnStart = schema.checkChild(start, '$text');
+    const isTextAllowedOnEnd = schema.checkChild(end, '$text');
+    const startLimitElement = schema.getLimitElement(start);
+    const endLimitElement = schema.getLimitElement(end);
+    // Ranges which both end are inside the same limit element (or root) might needs only minor fix.
+    if (startLimitElement === endLimitElement) {
+        // Range is valid when both position allows to place a text:
+        // - <block>f[oobarba]z</block>
+        // This would be "fixed" by a next check but as it will be the same it's better to return null so the selection stays the same.
+        if (isTextAllowedOnStart && isTextAllowedOnEnd) {
+            return null;
+        }
+        // Range that is on non-limit element (or is partially) must be fixed so it is placed inside the block around $text:
+        // - [<block>foo</block>]    ->    <block>[foo]</block>
+        // - [<block>foo]</block>    ->    <block>[foo]</block>
+        // - <block>f[oo</block>]    ->    <block>f[oo]</block>
+        // - [<block>foo</block><selectable></selectable>]    ->    <block>[foo</block><selectable></selectable>]
+        if (checkSelectionOnNonLimitElements(start, end, schema)) {
+            const isStartBeforeSelectable = start.nodeAfter && schema.isSelectable(start.nodeAfter);
+            const fixedStart = isStartBeforeSelectable ? null : schema.getNearestSelectionRange(start, 'forward');
+            const isEndAfterSelectable = end.nodeBefore && schema.isSelectable(end.nodeBefore);
+            const fixedEnd = isEndAfterSelectable ? null : schema.getNearestSelectionRange(end, 'backward');
+            // The schema.getNearestSelectionRange might return null - if that happens use original position.
+            const rangeStart = fixedStart ? fixedStart.start : start;
+            const rangeEnd = fixedEnd ? fixedEnd.end : end;
+            return new Range(rangeStart, rangeEnd);
+        }
+    }
+    const isStartInLimit = startLimitElement && !startLimitElement.is('rootElement');
+    const isEndInLimit = endLimitElement && !endLimitElement.is('rootElement');
+    // At this point we eliminated valid positions on text nodes so if one of range positions is placed inside a limit element
+    // then the range crossed limit element boundaries and needs to be fixed.
+    if (isStartInLimit || isEndInLimit) {
+        const bothInSameParent = start.nodeAfter && end.nodeBefore && start.nodeAfter.parent === end.nodeBefore.parent;
+        const expandStart = isStartInLimit && (!bothInSameParent || !isSelectable(start.nodeAfter, schema));
+        const expandEnd = isEndInLimit && (!bothInSameParent || !isSelectable(end.nodeBefore, schema));
+        // Although we've already found limit element on start/end positions we must find the outer-most limit element.
+        // as limit elements might be nested directly inside (ie table > tableRow > tableCell).
+        let fixedStart = start;
+        let fixedEnd = end;
+        if (expandStart) {
+            fixedStart = Position._createBefore(findOutermostLimitAncestor(startLimitElement, schema));
+        }
+        if (expandEnd) {
+            fixedEnd = Position._createAfter(findOutermostLimitAncestor(endLimitElement, schema));
+        }
+        return new Range(fixedStart, fixedEnd);
+    }
+    // Range was not fixed at this point so it is valid - ie it was placed around limit element already.
+    return null;
+}
+/**
+ * Finds the outer-most ancestor.
+ */ function findOutermostLimitAncestor(startingNode, schema) {
+    let isLimitNode = startingNode;
+    let parent = isLimitNode;
+    // Find outer most isLimit block as such blocks might be nested (ie. in tables).
+    while(schema.isLimit(parent) && parent.parent){
+        isLimitNode = parent;
+        parent = parent.parent;
+    }
+    return isLimitNode;
+}
+/**
+ * Checks whether any of range boundaries is placed around non-limit elements.
+ */ function checkSelectionOnNonLimitElements(start, end, schema) {
+    const startIsOnBlock = start.nodeAfter && !schema.isLimit(start.nodeAfter) || schema.checkChild(start, '$text');
+    const endIsOnBlock = end.nodeBefore && !schema.isLimit(end.nodeBefore) || schema.checkChild(end, '$text');
+    // We should fix such selection when one of those nodes needs fixing.
+    return startIsOnBlock || endIsOnBlock;
+}
+/**
+ * Returns a minimal non-intersecting array of ranges without duplicates.
+ *
+ * @param ranges Ranges to merge.
+ * @returns Array of unique and non-intersecting ranges.
+ */ function mergeIntersectingRanges(ranges) {
+    const rangesToMerge = [
+        ...ranges
+    ];
+    const rangeIndexesToRemove = new Set();
+    let currentRangeIndex = 1;
+    while(currentRangeIndex < rangesToMerge.length){
+        const currentRange = rangesToMerge[currentRangeIndex];
+        const previousRanges = rangesToMerge.slice(0, currentRangeIndex);
+        for (const [previousRangeIndex, previousRange] of previousRanges.entries()){
+            if (rangeIndexesToRemove.has(previousRangeIndex)) {
+                continue;
+            }
+            if (currentRange.isEqual(previousRange)) {
+                rangeIndexesToRemove.add(previousRangeIndex);
+            } else if (currentRange.isIntersecting(previousRange)) {
+                rangeIndexesToRemove.add(previousRangeIndex);
+                rangeIndexesToRemove.add(currentRangeIndex);
+                const mergedRange = currentRange.getJoined(previousRange);
+                rangesToMerge.push(mergedRange);
+            }
+        }
+        currentRangeIndex++;
+    }
+    const nonIntersectingRanges = rangesToMerge.filter((_, index)=>!rangeIndexesToRemove.has(index));
+    return nonIntersectingRanges;
+}
+/**
+ * Checks if node exists and if it's a selectable.
+ */ function isSelectable(node, schema) {
+    return node && schema.isSelectable(node);
+}
+
 // @if CK_DEBUG_ENGINE // const { dumpTrees, initDocumentDumping } = require( '../dev-utils/utils' );
 /**
  * A controller for the editing pipeline. The editing pipeline controls the {@link ~EditingController#model model} rendering,
@@ -22902,6 +23150,10 @@ function getFromAttributeCreator(config) {
         });
         // Convert selection from the view to the model when it changes in the view.
         this.listenTo(this.view.document, 'selectionChange', convertSelectionChange(this.model, this.mapper));
+        // Fix `beforeinput` target ranges so that they map to the valid model ranges.
+        this.listenTo(this.view.document, 'beforeinput', fixTargetRanges(this.mapper, this.model.schema, this.view), {
+            priority: 'high'
+        });
         // Attach default model converters.
         this.downcastDispatcher.on('insert:$text', insertText(), {
             priority: 'lowest'
@@ -23014,6 +23266,28 @@ function getFromAttributeCreator(config) {
         });
     }
 }
+/**
+ * Checks whether the target ranges provided by the `beforeInput` event can be properly mapped to model ranges and fixes them if needed.
+ *
+ * This is using the same logic as the selection post-fixer.
+ */ function fixTargetRanges(mapper, schema, view) {
+    return (evt, data)=>{
+        // The Renderer is disabled while composing on non-android browsers, so we can't be sure that target ranges
+        // could be properly mapped to view and model because the DOM and view tree drifted apart.
+        if (view.document.isComposing && !env.isAndroid) {
+            return;
+        }
+        for(let i = 0; i < data.targetRanges.length; i++){
+            const viewRange = data.targetRanges[i];
+            const modelRange = mapper.toModelRange(viewRange);
+            const correctedRange = tryFixingRange(modelRange, schema);
+            if (!correctedRange || correctedRange.isEqual(modelRange)) {
+                continue;
+            }
+            data.targetRanges[i] = mapper.toViewRange(correctedRange);
+        }
+    };
+}
 
 /**
  * The model's schema. It defines the allowed and disallowed structures of nodes as well as nodes' attributes.
@@ -34002,251 +34276,6 @@ DocumentFragment.prototype.is = function(type) {
     return false;
 }
 
-/**
- * Injects selection post-fixer to the model.
- *
- * The role of the selection post-fixer is to ensure that the selection is in a correct place
- * after a {@link module:engine/model/model~Model#change `change()`} block was executed.
- *
- * The correct position means that:
- *
- * * All collapsed selection ranges are in a place where the {@link module:engine/model/schema~Schema}
- * allows a `$text`.
- * * None of the selection's non-collapsed ranges crosses a {@link module:engine/model/schema~Schema#isLimit limit element}
- * boundary (a range must be rooted within one limit element).
- * * Only {@link module:engine/model/schema~Schema#isSelectable selectable elements} can be selected from the outside
- * (e.g. `[<paragraph>foo</paragraph>]` is invalid). This rule applies independently to both selection ends, so this
- * selection is correct: `<paragraph>f[oo</paragraph><imageBlock></imageBlock>]`.
- *
- * If the position is not correct, the post-fixer will automatically correct it.
- *
- * ## Fixing a non-collapsed selection
- *
- * See as an example a selection that starts in a P1 element and ends inside the text of a TD element
- * (`[` and `]` are range boundaries and `(l)` denotes an element defined as `isLimit=true`):
- *
- * ```
- * root
- *  |- element P1
- *  |   |- "foo"                                      root
- *  |- element TABLE (l)                   P1         TABLE             P2
- *  |   |- element TR (l)                 f o[o     TR      TR         b a r
- *  |   |   |- element TD (l)                       TD      TD
- *  |   |       |- "aaa"                          a]a a    b b b
- *  |   |- element TR (l)
- *  |   |   |- element TD (l)                           ||
- *  |   |       |- "bbb"                                ||
- *  |- element P2                                       VV
- *  |   |- "bar"
- *                                                    root
- *                                         P1         TABLE]            P2
- *                                        f o[o     TR      TR         b a r
- *                                                  TD      TD
- *                                                a a a    b b b
- * ```
- *
- * In the example above, the TABLE, TR and TD are defined as `isLimit=true` in the schema. The range which is not contained within
- * a single limit element must be expanded to select the outermost limit element. The range end is inside the text node of the TD element.
- * As the TD element is a child of the TR and TABLE elements, where both are defined as `isLimit=true` in the schema, the range must be
- * expanded to select the whole TABLE element.
- *
- * **Note** If the selection contains multiple ranges, the method returns a minimal set of ranges that are not intersecting after expanding
- * them to select `isLimit=true` elements.
- */ function injectSelectionPostFixer(model) {
-    model.document.registerPostFixer((writer)=>selectionPostFixer(writer, model));
-}
-/**
- * The selection post-fixer.
- */ function selectionPostFixer(writer, model) {
-    const selection = model.document.selection;
-    const schema = model.schema;
-    const ranges = [];
-    let wasFixed = false;
-    for (const modelRange of selection.getRanges()){
-        // Go through all ranges in selection and try fixing each of them.
-        // Those ranges might overlap but will be corrected later.
-        const correctedRange = tryFixingRange(modelRange, schema);
-        // "Selection fixing" algorithms sometimes get lost. In consequence, it may happen
-        // that a new range is returned but, in fact, it has the same positions as the original
-        // range anyway. If this range is not discarded, a new selection will be set and that,
-        // for instance, would destroy the selection attributes. Let's make sure that the post-fixer
-        // actually worked first before setting a new selection.
-        //
-        // https://github.com/ckeditor/ckeditor5/issues/6693
-        if (correctedRange && !correctedRange.isEqual(modelRange)) {
-            ranges.push(correctedRange);
-            wasFixed = true;
-        } else {
-            ranges.push(modelRange);
-        }
-    }
-    // If any of ranges were corrected update the selection.
-    if (wasFixed) {
-        writer.setSelection(mergeIntersectingRanges(ranges), {
-            backward: selection.isBackward
-        });
-    }
-    return false;
-}
-/**
- * Tries fixing a range if it's incorrect.
- *
- * **Note:** This helper is used by the selection post-fixer and to fix the `beforeinput` target ranges.
- *
- * @returns Returns fixed range or null if range is valid.
- */ function tryFixingRange(range, schema) {
-    if (range.isCollapsed) {
-        return tryFixingCollapsedRange(range, schema);
-    }
-    return tryFixingNonCollapsedRage(range, schema);
-}
-/**
- * Tries to fix collapsed ranges.
- *
- * * Fixes situation when a range is in a place where $text is not allowed
- *
- * @param range Collapsed range to fix.
- * @returns Returns fixed range or null if range is valid.
- */ function tryFixingCollapsedRange(range, schema) {
-    const originalPosition = range.start;
-    const nearestSelectionRange = schema.getNearestSelectionRange(originalPosition);
-    // This might be null, i.e. when the editor data is empty or the selection is inside a limit element
-    // that doesn't allow text inside.
-    // In the first case, there is no need to fix the selection range.
-    // In the second, let's go up to the outer selectable element
-    if (!nearestSelectionRange) {
-        const ancestorObject = originalPosition.getAncestors().reverse().find((item)=>schema.isObject(item));
-        if (ancestorObject) {
-            return Range._createOn(ancestorObject);
-        }
-        return null;
-    }
-    if (!nearestSelectionRange.isCollapsed) {
-        return nearestSelectionRange;
-    }
-    const fixedPosition = nearestSelectionRange.start;
-    // Fixed position is the same as original - no need to return corrected range.
-    if (originalPosition.isEqual(fixedPosition)) {
-        return null;
-    }
-    return new Range(fixedPosition);
-}
-/**
- * Tries to fix an expanded range.
- *
- * @param range Expanded range to fix.
- * @returns Returns fixed range or null if range is valid.
- */ function tryFixingNonCollapsedRage(range, schema) {
-    const { start, end } = range;
-    const isTextAllowedOnStart = schema.checkChild(start, '$text');
-    const isTextAllowedOnEnd = schema.checkChild(end, '$text');
-    const startLimitElement = schema.getLimitElement(start);
-    const endLimitElement = schema.getLimitElement(end);
-    // Ranges which both end are inside the same limit element (or root) might needs only minor fix.
-    if (startLimitElement === endLimitElement) {
-        // Range is valid when both position allows to place a text:
-        // - <block>f[oobarba]z</block>
-        // This would be "fixed" by a next check but as it will be the same it's better to return null so the selection stays the same.
-        if (isTextAllowedOnStart && isTextAllowedOnEnd) {
-            return null;
-        }
-        // Range that is on non-limit element (or is partially) must be fixed so it is placed inside the block around $text:
-        // - [<block>foo</block>]    ->    <block>[foo]</block>
-        // - [<block>foo]</block>    ->    <block>[foo]</block>
-        // - <block>f[oo</block>]    ->    <block>f[oo]</block>
-        // - [<block>foo</block><selectable></selectable>]    ->    <block>[foo</block><selectable></selectable>]
-        if (checkSelectionOnNonLimitElements(start, end, schema)) {
-            const isStartBeforeSelectable = start.nodeAfter && schema.isSelectable(start.nodeAfter);
-            const fixedStart = isStartBeforeSelectable ? null : schema.getNearestSelectionRange(start, 'forward');
-            const isEndAfterSelectable = end.nodeBefore && schema.isSelectable(end.nodeBefore);
-            const fixedEnd = isEndAfterSelectable ? null : schema.getNearestSelectionRange(end, 'backward');
-            // The schema.getNearestSelectionRange might return null - if that happens use original position.
-            const rangeStart = fixedStart ? fixedStart.start : start;
-            const rangeEnd = fixedEnd ? fixedEnd.end : end;
-            return new Range(rangeStart, rangeEnd);
-        }
-    }
-    const isStartInLimit = startLimitElement && !startLimitElement.is('rootElement');
-    const isEndInLimit = endLimitElement && !endLimitElement.is('rootElement');
-    // At this point we eliminated valid positions on text nodes so if one of range positions is placed inside a limit element
-    // then the range crossed limit element boundaries and needs to be fixed.
-    if (isStartInLimit || isEndInLimit) {
-        const bothInSameParent = start.nodeAfter && end.nodeBefore && start.nodeAfter.parent === end.nodeBefore.parent;
-        const expandStart = isStartInLimit && (!bothInSameParent || !isSelectable(start.nodeAfter, schema));
-        const expandEnd = isEndInLimit && (!bothInSameParent || !isSelectable(end.nodeBefore, schema));
-        // Although we've already found limit element on start/end positions we must find the outer-most limit element.
-        // as limit elements might be nested directly inside (ie table > tableRow > tableCell).
-        let fixedStart = start;
-        let fixedEnd = end;
-        if (expandStart) {
-            fixedStart = Position._createBefore(findOutermostLimitAncestor(startLimitElement, schema));
-        }
-        if (expandEnd) {
-            fixedEnd = Position._createAfter(findOutermostLimitAncestor(endLimitElement, schema));
-        }
-        return new Range(fixedStart, fixedEnd);
-    }
-    // Range was not fixed at this point so it is valid - ie it was placed around limit element already.
-    return null;
-}
-/**
- * Finds the outer-most ancestor.
- */ function findOutermostLimitAncestor(startingNode, schema) {
-    let isLimitNode = startingNode;
-    let parent = isLimitNode;
-    // Find outer most isLimit block as such blocks might be nested (ie. in tables).
-    while(schema.isLimit(parent) && parent.parent){
-        isLimitNode = parent;
-        parent = parent.parent;
-    }
-    return isLimitNode;
-}
-/**
- * Checks whether any of range boundaries is placed around non-limit elements.
- */ function checkSelectionOnNonLimitElements(start, end, schema) {
-    const startIsOnBlock = start.nodeAfter && !schema.isLimit(start.nodeAfter) || schema.checkChild(start, '$text');
-    const endIsOnBlock = end.nodeBefore && !schema.isLimit(end.nodeBefore) || schema.checkChild(end, '$text');
-    // We should fix such selection when one of those nodes needs fixing.
-    return startIsOnBlock || endIsOnBlock;
-}
-/**
- * Returns a minimal non-intersecting array of ranges without duplicates.
- *
- * @param ranges Ranges to merge.
- * @returns Array of unique and non-intersecting ranges.
- */ function mergeIntersectingRanges(ranges) {
-    const rangesToMerge = [
-        ...ranges
-    ];
-    const rangeIndexesToRemove = new Set();
-    let currentRangeIndex = 1;
-    while(currentRangeIndex < rangesToMerge.length){
-        const currentRange = rangesToMerge[currentRangeIndex];
-        const previousRanges = rangesToMerge.slice(0, currentRangeIndex);
-        for (const [previousRangeIndex, previousRange] of previousRanges.entries()){
-            if (rangeIndexesToRemove.has(previousRangeIndex)) {
-                continue;
-            }
-            if (currentRange.isEqual(previousRange)) {
-                rangeIndexesToRemove.add(previousRangeIndex);
-            } else if (currentRange.isIntersecting(previousRange)) {
-                rangeIndexesToRemove.add(previousRangeIndex);
-                rangeIndexesToRemove.add(currentRangeIndex);
-                const mergedRange = currentRange.getJoined(previousRange);
-                rangesToMerge.push(mergedRange);
-            }
-        }
-        currentRangeIndex++;
-    }
-    const nonIntersectingRanges = rangesToMerge.filter((_, index)=>!rangeIndexesToRemove.has(index));
-    return nonIntersectingRanges;
-}
-/**
- * Checks if node exists and if it's a selectable.
- */ function isSelectable(node, schema) {
-    return node && schema.isSelectable(node);
-}
-
 /**
  * Deletes content of the selection and merge siblings. The resulting selection is always collapsed.
  *
@@ -39263,5 +39292,5 @@ function* convertAttributes(attributes, converter) {
     }
 }
 
-export { AttributeElement, AttributeOperation, BubblingEventInfo, ClickObserver, Conversion, DataController, DataTransfer, DocumentFragment, DocumentSelection, DomConverter, DomEventData, DomEventObserver, DowncastWriter, EditingController, View as EditingView, Element, FocusObserver, History, HtmlDataProcessor, InsertOperation, LivePosition, LiveRange, MarkerOperation, Matcher, MergeOperation, Model, MouseObserver, MoveOperation, NoOperation, Observer, OperationFactory, Position, Range, RenameOperation, Renderer, RootAttributeOperation, RootOperation, SchemaContext, SplitOperation, StylesMap, StylesProcessor, TabObserver, Text, TextProxy, TouchObserver, TreeWalker, UpcastWriter, AttributeElement as ViewAttributeElement, ContainerElement as ViewContainerElement, Document$1 as ViewDocument, DocumentFragment$1 as ViewDocumentFragment, EditableElement as ViewEditableElement, Element$1 as ViewElement, EmptyElement as ViewEmptyElement, RawElement as ViewRawElement, RootEditableElement as ViewRootEditableElement, Text$1 as ViewText, TreeWalker$1 as ViewTreeWalker, UIElement as ViewUIElement, XmlDataProcessor, getData as _getModelData, getData$1 as _getViewData, parse as _parseModel, parse$1 as _parseView, setData as _setModelData, setData$1 as _setViewData, stringify as _stringifyModel, stringify$1 as _stringifyView, tryFixingRange as _tryFixingModelRange, addBackgroundRules, addBorderRules, addMarginRules, addPaddingRules, autoParagraphEmptyRoots, disablePlaceholder, enablePlaceholder, getBoxSidesShorthandValue, getBoxSidesValueReducer, getBoxSidesValues, getFillerOffset$4 as getFillerOffset, getPositionShorthandNormalizer, getShorthandValues, hidePlaceholder, isAttachment, isColor, isLength, isLineStyle, isParagraphable, isPercentage, isPosition, isRepeat, isURL, needsPlaceholder, showPlaceholder, transformSets, wrapInParagraph };
+export { AttributeElement, AttributeOperation, BubblingEventInfo, ClickObserver, Conversion, DataController, DataTransfer, DocumentFragment, DocumentSelection, DomConverter, DomEventData, DomEventObserver, DowncastWriter, EditingController, View as EditingView, Element, FocusObserver, History, HtmlDataProcessor, InsertOperation, LivePosition, LiveRange, MarkerOperation, Matcher, MergeOperation, Model, MouseObserver, MoveOperation, NoOperation, Observer, OperationFactory, Position, Range, RenameOperation, Renderer, RootAttributeOperation, RootOperation, SchemaContext, SplitOperation, StylesMap, StylesProcessor, TabObserver, Text, TextProxy, TouchObserver, TreeWalker, UpcastWriter, AttributeElement as ViewAttributeElement, ContainerElement as ViewContainerElement, Document$1 as ViewDocument, DocumentFragment$1 as ViewDocumentFragment, EditableElement as ViewEditableElement, Element$1 as ViewElement, EmptyElement as ViewEmptyElement, RawElement as ViewRawElement, RootEditableElement as ViewRootEditableElement, Text$1 as ViewText, TreeWalker$1 as ViewTreeWalker, UIElement as ViewUIElement, XmlDataProcessor, getData as _getModelData, getData$1 as _getViewData, parse as _parseModel, parse$1 as _parseView, setData as _setModelData, setData$1 as _setViewData, stringify as _stringifyModel, stringify$1 as _stringifyView, addBackgroundRules, addBorderRules, addMarginRules, addPaddingRules, autoParagraphEmptyRoots, disablePlaceholder, enablePlaceholder, getBoxSidesShorthandValue, getBoxSidesValueReducer, getBoxSidesValues, getFillerOffset$4 as getFillerOffset, getPositionShorthandNormalizer, getShorthandValues, hidePlaceholder, isAttachment, isColor, isLength, isLineStyle, isParagraphable, isPercentage, isPosition, isRepeat, isURL, needsPlaceholder, showPlaceholder, transformSets, wrapInParagraph };
 //# sourceMappingURL=index.js.map