@ckeditor/ckeditor5-engine 45.2.1 → 46.0.0-alpha.0

package/src/model/schema.js

@@ -5,11 +5,11 @@
 /**
  * @module engine/model/schema
  */
-import Element from './element.js';
-import Position from './position.js';
-import Range from './range.js';
-import Text from './text.js';
-import TreeWalker from './treewalker.js';
+import { ModelElement } from './element.js';
+import { ModelPosition } from './position.js';
+import { ModelRange } from './range.js';
+import { ModelText } from './text.js';
+import { ModelTreeWalker } from './treewalker.js';
 import { CKEditorError, first, ObservableMixin } from '@ckeditor/ckeditor5-utils';
 /**
  * The model's schema. It defines the allowed and disallowed structures of nodes as well as nodes' attributes.
@@ -24,27 +24,28 @@ import { CKEditorError, first, ObservableMixin } from '@ckeditor/ckeditor5-utils
  * {@glink framework/architecture/editing-engine Introduction to the Editing engine architecture} guide.
  * * The {@glink framework/deep-dive/schema Schema deep-dive} guide.
  */
-export default class Schema extends /* #__PURE__ */ ObservableMixin() {
+export class ModelSchema extends /* #__PURE__ */ ObservableMixin() {
     _sourceDefinitions = {};
     /**
      * A dictionary containing attribute properties.
      */
     _attributeProperties = Object.create(null);
     /**
-     * Stores additional callbacks registered for schema items, which are evaluated when {@link ~Schema#checkChild} is called.
+     * Stores additional callbacks registered for schema items, which are evaluated when {@link ~ModelSchema#checkChild} is called.
      *
      * Keys are schema item names for which the callbacks are registered. Values are arrays with the callbacks.
      *
-     * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every {@link ~Schema#checkChild} call.
+     * Some checks are added under {@link ~ModelSchema#_genericCheckSymbol} key, these are
+     * evaluated for every {@link ~ModelSchema#checkChild} call.
      */
     _customChildChecks = new Map();
     /**
-     * Stores additional callbacks registered for attribute names, which are evaluated when {@link ~Schema#checkAttribute} is called.
+     * Stores additional callbacks registered for attribute names, which are evaluated when {@link ~ModelSchema#checkAttribute} is called.
      *
      * Keys are schema attribute names for which the callbacks are registered. Values are arrays with the callbacks.
      *
-     * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every
-     * {@link ~Schema#checkAttribute} call.
+     * Some checks are added under {@link ~ModelSchema#_genericCheckSymbol} key, these are evaluated for every
+     * {@link ~ModelSchema#checkAttribute} call.
      */
     _customAttributeChecks = new Map();
     _genericCheckSymbol = Symbol('$generic');
@@ -57,10 +58,10 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         this.decorate('checkChild');
         this.decorate('checkAttribute');
         this.on('checkAttribute', (evt, args) => {
-            args[0] = new SchemaContext(args[0]);
+            args[0] = new ModelSchemaContext(args[0]);
         }, { priority: 'highest' });
         this.on('checkChild', (evt, args) => {
-            args[0] = new SchemaContext(args[0]);
+            args[0] = new ModelSchemaContext(args[0]);
             args[1] = this.getDefinition(args[1]);
         }, { priority: 'highest' });
     }
@@ -80,7 +81,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
              *
              * This situation may happen when:
              *
-             * * Two or more plugins called {@link module:engine/model/schema~Schema#register `register()`} with the same name.
+             * * Two or more plugins called {@link module:engine/model/schema~ModelSchema#register `register()`} with the same name.
              * This will usually mean that there is a collision between plugins which try to use the same element in the model.
              * Unfortunately, the only way to solve this is by modifying one of these plugins to use a unique model element name.
              * * A single plugin was loaded twice. This happens when it is installed by npm/yarn in two versions
@@ -132,7 +133,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
              * Cannot extend an item which was not registered yet.
              *
              * This error happens when a plugin tries to extend the schema definition of an item which was not
-             * {@link module:engine/model/schema~Schema#register registered} yet.
+             * {@link module:engine/model/schema~ModelSchema#register registered} yet.
              *
              * @param itemName The name of the model element which is being extended.
              * @error schema-cannot-extend-missing-item
@@ -174,7 +175,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         else if ('is' in item && (item.is('$text') || item.is('$textProxy'))) {
             itemName = '$text';
         }
-        // Element or module:engine/model/schema~SchemaContextItem.
+        // Element or module:engine/model/schema~ModelSchemaContextItem.
         else {
             itemName = item.name;
         }
@@ -194,7 +195,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     }
     /**
      * Returns `true` if the given item is defined to be
-     * a block by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isBlock` property.
+     * a block by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isBlock` property.
      *
      * ```ts
      * schema.isBlock( 'paragraph' ); // -> true
@@ -215,9 +216,9 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Returns `true` if the given item should be treated as a limit element.
      *
      * It considers an item to be a limit element if its
-     * {@link module:engine/model/schema~SchemaItemDefinition}'s
-     * {@link module:engine/model/schema~SchemaItemDefinition#isLimit `isLimit`} or
-     * {@link module:engine/model/schema~SchemaItemDefinition#isObject `isObject`} property
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition}'s
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isLimit `isLimit`} or
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isObject `isObject`} property
      * was set to `true`.
      *
      * ```ts
@@ -241,8 +242,8 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Returns `true` if the given item should be treated as an object element.
      *
      * It considers an item to be an object element if its
-     * {@link module:engine/model/schema~SchemaItemDefinition}'s
-     * {@link module:engine/model/schema~SchemaItemDefinition#isObject `isObject`} property
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition}'s
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isObject `isObject`} property
      * was set to `true`.
      *
      * ```ts
@@ -267,7 +268,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     }
     /**
      * Returns `true` if the given item is defined to be
-     * an inline element by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isInline` property.
+     * an inline element by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isInline` property.
      *
      * ```ts
      * schema.isInline( 'paragraph' ); // -> false
@@ -286,7 +287,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     }
     /**
      * Returns `true` if the given item is defined to be
-     * a selectable element by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isSelectable` property.
+     * a selectable element by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isSelectable` property.
      *
      * ```ts
      * schema.isSelectable( 'paragraph' ); // -> false
@@ -310,7 +311,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     }
     /**
      * Returns `true` if the given item is defined to be
-     * a content by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isContent` property.
+     * a content by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isContent` property.
      *
      * ```ts
      * schema.isContent( 'paragraph' ); // -> false
@@ -345,8 +346,9 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * schema.checkChild( model.document.getRoot(), paragraph ); // -> true
      * ```
      *
-     * Both {@link module:engine/model/schema~Schema#addChildCheck callback checks} and declarative rules (added when
-     * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+     * Both {@link module:engine/model/schema~ModelSchema#addChildCheck callback checks} and declarative rules (added when
+     * {@link module:engine/model/schema~ModelSchema#register registering} and
+     * {@link module:engine/model/schema~ModelSchema#extend extending} items)
      * are evaluated when this method is called.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
@@ -354,14 +356,14 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Note that when verifying whether the given node can be a child of the given context, the schema also verifies the entire
      * context – from its root to its last element. Therefore, it is possible for `checkChild()` to return `false` even though
      * the `context` last element can contain the checked child. It happens if one of the `context` elements does not allow its child.
-     * When `context` is verified, {@link module:engine/model/schema~Schema#addChildCheck custom checks} are considered as well.
+     * When `context` is verified, {@link module:engine/model/schema~ModelSchema#addChildCheck custom checks} are considered as well.
      *
      * @fires checkChild
      * @param context The context in which the child will be checked.
      * @param def The child to check.
      */
     checkChild(context, def) {
-        // Note: `context` and `def` are already normalized here to `SchemaContext` and `SchemaCompiledItemDefinition`.
+        // Note: `context` and `def` are already normalized here to `ModelSchemaContext` and `ModelSchemaCompiledItemDefinition`.
         if (!def) {
             return false;
         }
@@ -380,8 +382,9 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * schema.checkAttribute( textNode, 'bold' ); // -> true
      * ```
      *
-     * Both {@link module:engine/model/schema~Schema#addAttributeCheck callback checks} and declarative rules (added when
-     * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+     * Both {@link module:engine/model/schema~ModelSchema#addAttributeCheck callback checks} and declarative rules (added when
+     * {@link module:engine/model/schema~ModelSchema#register registering} and
+     * {@link module:engine/model/schema~ModelSchema#extend extending} items)
      * are evaluated when this method is called.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
@@ -391,7 +394,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * @param attributeName Name of attribute to check in the given context.
      */
     checkAttribute(context, attributeName) {
-        // Note: `context` is already normalized here to `SchemaContext`.
+        // Note: `context` is already normalized here to `ModelSchemaContext`.
         const def = this.getDefinition(context.last);
         if (!def) {
             return false;
@@ -408,20 +411,20 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * In other words – both elements are not a limit elements and whether `elementToMerge`'s children
      * {@link #checkChild are allowed} in the `positionOrBaseElement`.
      *
-     * This check ensures that elements merged with {@link module:engine/model/writer~Writer#merge `Writer#merge()`}
+     * This check ensures that elements merged with {@link module:engine/model/writer~ModelWriter#merge `Writer#merge()`}
      * will be valid.
      *
-     * Instead of elements, you can pass the instance of the {@link module:engine/model/position~Position} class as the
+     * Instead of elements, you can pass the instance of the {@link module:engine/model/position~ModelPosition} class as the
      * `positionOrBaseElement`. It means that the elements before and after the position will be checked whether they can be merged.
      *
      * @param positionOrBaseElement The position or base element to which the `elementToMerge` will be merged.
      * @param elementToMerge The element to merge. Required if `positionOrBaseElement` is an element.
      */
     checkMerge(positionOrBaseElement, elementToMerge) {
-        if (positionOrBaseElement instanceof Position) {
+        if (positionOrBaseElement instanceof ModelPosition) {
             const nodeBefore = positionOrBaseElement.nodeBefore;
             const nodeAfter = positionOrBaseElement.nodeAfter;
-            if (!(nodeBefore instanceof Element)) {
+            if (!(nodeBefore instanceof ModelElement)) {
                 /**
                  * The node before the merge position must be an element.
                  *
@@ -429,7 +432,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
                  */
                 throw new CKEditorError('schema-check-merge-no-element-before', this);
             }
-            if (!(nodeAfter instanceof Element)) {
+            if (!(nodeAfter instanceof ModelElement)) {
                 /**
                  * The node after the merge position must be an element.
                  *
@@ -453,7 +456,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Allows registering a callback to the {@link #checkChild} method calls.
      *
      * Callbacks allow you to implement rules which are not otherwise possible to achieve
-     * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
+     * by using the declarative API of {@link module:engine/model/schema~ModelSchemaItemDefinition}.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
      *
@@ -506,9 +509,9 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Adding callbacks this way can also negatively impact editor performance.
      *
      * @param callback The callback to be called. It is called with two parameters:
-     * {@link module:engine/model/schema~SchemaContext} (context) instance and
-     * {@link module:engine/model/schema~SchemaCompiledItemDefinition} (definition). The callback may return `true/false` to override
-     * `checkChild()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks) will define
+     * {@link module:engine/model/schema~ModelSchemaContext} (context) instance and
+     * {@link module:engine/model/schema~ModelSchemaCompiledItemDefinition} (definition). The callback may return `true/false` to
+     * override `checkChild()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks) will define
      * `checkChild()`'s return value.
      * @param itemName Name of the schema item for which the callback is registered. If specified, the callback will be run only for
      * `checkChild()` calls which `def` parameter matches the `itemName`. Otherwise, the callback will run for every `checkChild` call.
@@ -523,7 +526,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Allows registering a callback to the {@link #checkAttribute} method calls.
      *
      * Callbacks allow you to implement rules which are not otherwise possible to achieve
-     * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
+     * by using the declarative API of {@link module:engine/model/schema~ModelSchemaItemDefinition}.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
      *
@@ -576,7 +579,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Adding callbacks this way can also negatively impact editor performance.
      *
      * @param callback The callback to be called. It is called with two parameters:
-     * {@link module:engine/model/schema~SchemaContext `context`} and attribute name. The callback may return `true` or `false`, to
+     * {@link module:engine/model/schema~ModelSchemaContext `context`} and attribute name. The callback may return `true` or `false`, to
      * override `checkAttribute()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks)
      * will define `checkAttribute()`'s return value.
      * @param attributeName Name of the attribute for which the callback is registered. If specified, the callback will be run only for
@@ -590,7 +593,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     }
     /**
      * This method allows assigning additional metadata to the model attributes. For example,
-     * {@link module:engine/model/schema~AttributeProperties `AttributeProperties#isFormatting` property} is
+     * {@link module:engine/model/schema~ModelAttributeProperties `AttributeProperties#isFormatting` property} is
      * used to mark formatting attributes (like `bold` or `italic`).
      *
      * ```ts
@@ -606,7 +609,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * ```
      *
      * Properties are not limited to members defined in the
-     * {@link module:engine/model/schema~AttributeProperties `AttributeProperties` type} and you can also use custom properties:
+     * {@link module:engine/model/schema~ModelAttributeProperties `AttributeProperties` type} and you can also use custom properties:
      *
      * ```ts
      * schema.setAttributeProperties( 'blockQuote', {
@@ -644,7 +647,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         return this._attributeProperties[attributeName] || Object.create(null);
     }
     /**
-     * Returns the lowest {@link module:engine/model/schema~Schema#isLimit limit element} containing the entire
+     * Returns the lowest {@link module:engine/model/schema~ModelSchema#isLimit limit element} containing the entire
      * selection/range/position or the root otherwise.
      *
      * @param selectionOrRangeOrPosition The selection/range/position to check.
@@ -652,11 +655,11 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      */
     getLimitElement(selectionOrRangeOrPosition) {
         let element;
-        if (selectionOrRangeOrPosition instanceof Position) {
+        if (selectionOrRangeOrPosition instanceof ModelPosition) {
             element = selectionOrRangeOrPosition.parent;
         }
         else {
-            const ranges = selectionOrRangeOrPosition instanceof Range ?
+            const ranges = selectionOrRangeOrPosition instanceof ModelRange ?
                 [selectionOrRangeOrPosition] :
                 Array.from(selectionOrRangeOrPosition.getRanges());
             // Find the common ancestor for all selection's ranges.
@@ -694,7 +697,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
             const firstPosition = selection.getFirstPosition();
             const context = [
                 ...firstPosition.getAncestors(),
-                new Text('', selection.getAttributes())
+                new ModelText('', selection.getAttributes())
             ];
             // Check whether schema allows for a text with the attribute in the selection.
             return this.checkAttribute(context, attribute);
@@ -728,12 +731,12 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         }
     }
     /**
-     * Basing on given `position`, finds and returns a {@link module:engine/model/range~Range range} which is
+     * Basing on given `position`, finds and returns a {@link module:engine/model/range~ModelRange range} which is
      * nearest to that `position` and is a correct range for selection.
      *
      * The correct selection range might be collapsed when it is located in a position where the text node can be placed.
      * Non-collapsed range is returned when selection can be placed around element marked as an "object" in
-     * the {@link module:engine/model/schema~Schema schema}.
+     * the {@link module:engine/model/schema~ModelSchema schema}.
      *
      * Direction of searching for the nearest correct selection range can be specified as:
      *
@@ -755,22 +758,22 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         }
         // Return collapsed range if provided position is valid.
         if (this.checkChild(position, '$text')) {
-            return new Range(position);
+            return new ModelRange(position);
         }
         let backwardWalker, forwardWalker;
         // Never leave a limit element.
         const limitElement = position.getAncestors().reverse().find(item => this.isLimit(item)) ||
             position.root;
         if (direction == 'both' || direction == 'backward') {
-            backwardWalker = new TreeWalker({
-                boundaries: Range._createIn(limitElement),
+            backwardWalker = new ModelTreeWalker({
+                boundaries: ModelRange._createIn(limitElement),
                 startPosition: position,
                 direction: 'backward'
             });
         }
         if (direction == 'both' || direction == 'forward') {
-            forwardWalker = new TreeWalker({
-                boundaries: Range._createIn(limitElement),
+            forwardWalker = new ModelTreeWalker({
+                boundaries: ModelRange._createIn(limitElement),
                 startPosition: position
             });
         }
@@ -778,10 +781,10 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
             const type = (data.walker == backwardWalker ? 'elementEnd' : 'elementStart');
             const value = data.value;
             if (value.type == type && this.isObject(value.item)) {
-                return Range._createOn(value.item);
+                return ModelRange._createOn(value.item);
             }
             if (this.checkChild(value.nextPosition, '$text')) {
-                return new Range(value.nextPosition);
+                return new ModelRange(value.nextPosition);
             }
         }
         return null;
@@ -789,8 +792,8 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     /**
      * Tries to find position ancestors that allow to insert a given node.
      * It starts searching from the given position and goes node by node to the top of the model tree
-     * as long as a {@link module:engine/model/schema~Schema#isLimit limit element}, an
-     * {@link module:engine/model/schema~Schema#isObject object element} or a topmost ancestor is not reached.
+     * as long as a {@link module:engine/model/schema~ModelSchema#isLimit limit element}, an
+     * {@link module:engine/model/schema~ModelSchema#isObject object element} or a topmost ancestor is not reached.
      *
      * @param position The position that the search will start from.
      * @param node The node for which an allowed parent should be found or its name.
@@ -841,7 +844,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
             // is at start of an element. Using positions prevent from omitting merged nodes
             // see https://github.com/ckeditor/ckeditor5-engine/issues/1789.
             else {
-                const rangeInNode = Range._createIn(node);
+                const rangeInNode = ModelRange._createIn(node);
                 const positionsInRange = rangeInNode.getPositions();
                 for (const position of positionsInRange) {
                     const item = position.nodeBefore || position.parent;
@@ -877,7 +880,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Creates an instance of the schema context.
      */
     createContext(context) {
-        return new SchemaContext(context);
+        return new ModelSchemaContext(context);
     }
     _clearCache() {
         this._compiledDefinitions = null;
@@ -995,7 +998,7 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
      * Takes a flat range and an attribute name. Traverses the range recursively and deeply to find and return all ranges
      * inside the given range on which the attribute can be applied.
      *
-     * This is a helper function for {@link ~Schema#getValidRanges}.
+     * This is a helper function for {@link ~ModelSchema#getValidRanges}.
      *
      * @param range The range to process.
      * @param attribute The name of the attribute to check.
@@ -1006,18 +1009,18 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         let end = range.start;
         for (const item of range.getItems({ shallow: true })) {
             if (item.is('element')) {
-                yield* this._getValidRangesForRange(Range._createIn(item), attribute);
+                yield* this._getValidRangesForRange(ModelRange._createIn(item), attribute);
             }
             if (!this.checkAttribute(item, attribute)) {
                 if (!start.isEqual(end)) {
-                    yield new Range(start, end);
+                    yield new ModelRange(start, end);
                 }
-                start = Position._createAfter(item);
+                start = ModelPosition._createAfter(item);
             }
-            end = Position._createAfter(item);
+            end = ModelPosition._createAfter(item);
         }
         if (!start.isEqual(end)) {
-            yield new Range(start, end);
+            yield new ModelRange(start, end);
         }
     }
     /**
@@ -1043,27 +1046,27 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
         const selectedElement = selection.getSelectedElement();
         if (selectedElement && this.isObject(selectedElement) && !this.isInline(selectedElement)) {
             if (place == 'before' || place == 'after') {
-                return new Range(Position._createAt(selectedElement, place));
+                return new ModelRange(ModelPosition._createAt(selectedElement, place));
             }
-            return Range._createOn(selectedElement);
+            return ModelRange._createOn(selectedElement);
         }
         const firstBlock = first(selection.getSelectedBlocks());
         // There are no block elements within ancestors (in the current limit element).
         if (!firstBlock) {
-            return new Range(selection.focus);
+            return new ModelRange(selection.focus);
         }
         // If inserting into an empty block – return position in that block. It will get
         // replaced with the image by insertContent(). #42.
         if (firstBlock.isEmpty) {
-            return new Range(Position._createAt(firstBlock, 0));
+            return new ModelRange(ModelPosition._createAt(firstBlock, 0));
         }
-        const positionAfter = Position._createAfter(firstBlock);
+        const positionAfter = ModelPosition._createAfter(firstBlock);
         // If selection is at the end of the block - return position after the block.
         if (selection.focus.isTouching(positionAfter)) {
-            return new Range(positionAfter);
+            return new ModelRange(positionAfter);
         }
         // Otherwise, return position before the block.
-        return new Range(Position._createBefore(firstBlock));
+        return new ModelRange(ModelPosition._createBefore(firstBlock));
     }
 }
 /**
@@ -1081,24 +1084,24 @@ export default class Schema extends /* #__PURE__ */ ObservableMixin() {
  * </$root>
  * ```
  *
- * The context of this position is its {@link module:engine/model/position~Position#getAncestors lists of ancestors}:
+ * The context of this position is its {@link module:engine/model/position~ModelPosition#getAncestors lists of ancestors}:
  *
  *		[ rootElement, blockQuoteElement, paragraphElement ]
  *
- * Contexts are used in the {@link module:engine/model/schema~Schema#event:checkChild `Schema#checkChild`} and
- * {@link module:engine/model/schema~Schema#event:checkAttribute `Schema#checkAttribute`} events as a definition
+ * Contexts are used in the {@link module:engine/model/schema~ModelSchema#event:checkChild `Schema#checkChild`} and
+ * {@link module:engine/model/schema~ModelSchema#event:checkAttribute `Schema#checkAttribute`} events as a definition
  * of a place in the document where the check occurs. The context instances are created based on the first arguments
- * of the {@link module:engine/model/schema~Schema#checkChild `Schema#checkChild()`} and
- * {@link module:engine/model/schema~Schema#checkAttribute `Schema#checkAttribute()`} methods so when
- * using these methods you need to use {@link module:engine/model/schema~SchemaContextDefinition}s.
+ * of the {@link module:engine/model/schema~ModelSchema#checkChild `Schema#checkChild()`} and
+ * {@link module:engine/model/schema~ModelSchema#checkAttribute `Schema#checkAttribute()`} methods so when
+ * using these methods you need to use {@link module:engine/model/schema~ModelSchemaContextDefinition}s.
  */
-export class SchemaContext {
+export class ModelSchemaContext {
     _items;
     /**
      * Creates an instance of the context.
      */
     constructor(context) {
-        if (context instanceof SchemaContext) {
+        if (context instanceof ModelSchemaContext) {
             return context;
         }
         let items;
@@ -1141,7 +1144,7 @@ export class SchemaContext {
      * Item can be added as:
      *
      * ```ts
-     * const context = new SchemaContext( [ '$root' ] );
+     * const context = new ModelSchemaContext( [ '$root' ] );
      *
      * // An element.
      * const fooElement = writer.createElement( 'fooElement' );
@@ -1155,14 +1158,14 @@ export class SchemaContext {
      * const newContext = context.push( 'barElement' ); // [ '$root', 'barElement' ]
      * ```
      *
-     * **Note** {@link module:engine/model/node~Node} that is already in the model tree will be added as the only item
+     * **Note** {@link module:engine/model/node~ModelNode} that is already in the model tree will be added as the only item
      * (without ancestors).
      *
      * @param item An item that will be added to the current context.
      * @returns A new schema context instance with an additional item.
      */
     push(item) {
-        const ctx = new SchemaContext([item]);
+        const ctx = new ModelSchemaContext([item]);
         ctx._items = [...this._items, ...ctx._items];
         return ctx;
     }
@@ -1170,7 +1173,7 @@ export class SchemaContext {
      * Returns a new schema context that is based on this context but has the last item removed.
      *
      * ```ts
-     * const ctxParagraph = new SchemaContext( [ '$root', 'blockQuote', 'paragraph' ] );
+     * const ctxParagraph = new ModelSchemaContext( [ '$root', 'blockQuote', 'paragraph' ] );
      * const ctxBlockQuote = ctxParagraph.trimLast(); // Items in `ctxBlockQuote` are: `$root` an `blockQuote`.
      * const ctxRoot = ctxBlockQuote.trimLast(); // Items in `ctxRoot` are: `$root`.
      * ```
@@ -1178,7 +1181,7 @@ export class SchemaContext {
      * @returns A new reduced schema context instance.
      */
     trimLast() {
-        const ctx = new SchemaContext([]);
+        const ctx = new ModelSchemaContext([]);
         ctx._items = this._items.slice(0, -1);
         return ctx;
     }
@@ -1198,7 +1201,7 @@ export class SchemaContext {
      * Checks whether the context ends with the given nodes.
      *
      * ```ts
-     * const ctx = new SchemaContext( [ rootElement, paragraphElement, textNode ] );
+     * const ctx = new ModelSchemaContext( [ rootElement, paragraphElement, textNode ] );
      *
      * ctx.endsWith( '$text' ); // -> true
      * ctx.endsWith( 'paragraph $text' ); // -> true
@@ -1213,7 +1216,7 @@ export class SchemaContext {
      * Checks whether the context starts with the given nodes.
      *
      * ```ts
-     * const ctx = new SchemaContext( [ rootElement, paragraphElement, textNode ] );
+     * const ctx = new ModelSchemaContext( [ rootElement, paragraphElement, textNode ] );
      *
      * ctx.endsWith( '$root' ); // -> true
      * ctx.endsWith( '$root paragraph' ); // -> true