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

package/src/model/liveposition.js

@@ -20,7 +20,7 @@ import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * have to be unbound.
  * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
  */
-export default class LivePosition extends EmitterMixin(Position) {
+export default class LivePosition extends /* #__PURE__ */ EmitterMixin(Position) {
     /**
      * Creates a live position.
      *

package/src/model/liverange.d.ts

@@ -19,7 +19,7 @@ declare const LiveRange_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof R
  * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
  * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
  */
-export default class LiveRange extends LiveRange_base {
+export default class LiveRange extends /* #__PURE__ */ LiveRange_base {
     /**
      * Creates a live range.
      *

package/src/model/liverange.js

@@ -15,7 +15,7 @@ import { EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
  * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
  */
-export default class LiveRange extends EmitterMixin(Range) {
+export default class LiveRange extends /* #__PURE__ */ EmitterMixin(Range) {
     /**
      * Creates a live range.
      *

package/src/model/markercollection.d.ts

@@ -27,7 +27,7 @@ declare const MarkerCollection_base: {
  *
  * @see module:engine/model/markercollection~Marker
  */
-export default class MarkerCollection extends MarkerCollection_base implements Iterable<Marker> {
+export default class MarkerCollection extends /* #__PURE__ */ MarkerCollection_base implements Iterable<Marker> {
     /**
      * Stores {@link ~Marker markers} added to the collection.
      */
@@ -205,7 +205,7 @@ declare const Marker_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Type
  *
  * `Marker` instances are created and destroyed only by {@link ~MarkerCollection MarkerCollection}.
  */
-declare class Marker extends Marker_base {
+declare class Marker extends /* #__PURE__ */ Marker_base {
     /**
      * Marker's name.
      */

package/src/model/markercollection.js

@@ -22,7 +22,7 @@ import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
  *
  * @see module:engine/model/markercollection~Marker
  */
-export default class MarkerCollection extends EmitterMixin() {
+export default class MarkerCollection extends /* #__PURE__ */ EmitterMixin() {
     constructor() {
         super(...arguments);
         /**
@@ -282,7 +282,7 @@ export default class MarkerCollection extends EmitterMixin() {
  *
  * `Marker` instances are created and destroyed only by {@link ~MarkerCollection MarkerCollection}.
  */
-class Marker extends EmitterMixin(TypeCheckable) {
+class Marker extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
     /**
      * Creates a marker instance.
      *

package/src/model/model.d.ts

@@ -28,7 +28,7 @@ declare const Model_base: {
  * Editor's data model. Read about the model in the
  * {@glink framework/architecture/editing-engine engine architecture} guide.
  */
-export default class Model extends Model_base {
+export default class Model extends /* #__PURE__ */ Model_base {
     /**
      * Model's marker collection.
      */

package/src/model/model.js

@@ -30,7 +30,7 @@ import { CKEditorError, ObservableMixin } from '@ckeditor/ckeditor5-utils';
  * Editor's data model. Read about the model in the
  * {@glink framework/architecture/editing-engine engine architecture} guide.
  */
-export default class Model extends ObservableMixin() {
+export default class Model extends /* #__PURE__ */ ObservableMixin() {
     // @if CK_DEBUG_ENGINE // private _operationLogs: Array<string>;
     // @if CK_DEBUG_ENGINE // private _appliedOperations: Array<Operation>;
     constructor() {

package/src/model/schema.d.ts

@@ -31,7 +31,7 @@ declare const Schema_base: {
  * {@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 Schema_base {
+export default class Schema extends /* #__PURE__ */ Schema_base {
     private readonly _sourceDefinitions;
     /**
      * A dictionary containing attribute properties.
@@ -673,9 +673,15 @@ export type SchemaCheckAttributeEvent = {
  * * {@link ~SchemaItemDefinition#allowIn `allowIn`} – Defines in which other items this item will be allowed.
  * * {@link ~SchemaItemDefinition#allowChildren `allowChildren`} – Defines which other items are allowed inside this item.
  * * {@link ~SchemaItemDefinition#allowAttributes `allowAttributes`} – Defines allowed attributes of the given item.
- * * {@link ~SchemaItemDefinition#allowContentOf `allowContentOf`} – Inherits "allowed children" from other items.
- * * {@link ~SchemaItemDefinition#allowWhere `allowWhere`} – Inherits "allowed in" from other items.
- * * {@link ~SchemaItemDefinition#allowAttributesOf `allowAttributesOf`} – Inherits attributes from other items.
+ * * {@link ~SchemaItemDefinition#disallowIn `disallowIn`} – Defines in which other items this item will be disallowed.
+ * * {@link ~SchemaItemDefinition#disallowChildren `disallowChildren`} – Defines which other items are disallowed inside this item.
+ * * {@link ~SchemaItemDefinition#disallowAttributes `disallowAttributes`} – Defines disallowed attributes of the given item.
+ * * {@link ~SchemaItemDefinition#allowContentOf `allowContentOf`} – Makes this item allow children that are also allowed in the
+ * specified items. This acknowledges disallow rules.
+ * * {@link ~SchemaItemDefinition#allowWhere `allowWhere`} – Makes this item allowed where the specified items are allowed. This
+ * acknowledges disallow rules.
+ * * {@link ~SchemaItemDefinition#allowAttributesOf `allowAttributesOf`} – Inherits attributes from other items. This acknowledges
+ * disallow rules.
  * * {@link ~SchemaItemDefinition#inheritTypesFrom `inheritTypesFrom`} – Inherits `is*` properties of other items.
  * * {@link ~SchemaItemDefinition#inheritAllFrom `inheritAllFrom`} –
  * A shorthand for `allowContentOf`, `allowWhere`, `allowAttributesOf`, `inheritTypesFrom`.
@@ -683,7 +689,6 @@ export type SchemaCheckAttributeEvent = {
  * # The `is*` properties
  *
  * There are a couple commonly used `is*` properties. Their role is to assign additional semantics to schema items.
- * You can define more properties but you will also need to implement support for them in the existing editor features.
  *
  * * {@link ~SchemaItemDefinition#isBlock `isBlock`} – Whether this item is paragraph-like.
  * Generally speaking, content is usually made out of blocks like paragraphs, list items, images, headings, etc.
@@ -804,6 +809,15 @@ export type SchemaCheckAttributeEvent = {
  * } );
  * ```
  *
+ * Register `inlineImage` as a kind of an inline object but disallow it inside captions:
+ *
+ * ```ts
+ * schema.register( 'imageInline', {
+ * 	inheritAllFrom: '$inlineObject',
+ * 	disallowIn: [ 'caption' ]
+ * } );
+ * ```
+ *
  * Make `listItem` inherit all from `$block` but also allow additional attributes:
  *
  * ```ts
@@ -847,6 +861,18 @@ export interface SchemaItemDefinition {
      * Defines allowed attributes of the given item.
      */
     allowAttributes?: string | Array<string>;
+    /**
+     * Defines in which other items this item will be disallowed. Takes precedence over allow rules.
+     */
+    disallowIn?: string | Array<string>;
+    /**
+     * Defines which other items are disallowed inside this item. Takes precedence over allow rules.
+     */
+    disallowChildren?: string | Array<string>;
+    /**
+     * Defines disallowed attributes for this item. Takes precedence over allow rules.
+     */
+    disallowAttributes?: string | Array<string>;
     /**
      * Inherits "allowed children" from other items.
      */
@@ -856,7 +882,7 @@ export interface SchemaItemDefinition {
      */
     allowWhere?: string | Array<string>;
     /**
-     * Inherits attributes from other items.
+     * Inherits "allowed attributes" from other items.
      */
     allowAttributesOf?: string | Array<string>;
     /**

package/src/model/schema.js

@@ -24,7 +24,7 @@ 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 ObservableMixin() {
+export default class Schema extends /* #__PURE__ */ ObservableMixin() {
     /**
      * Creates a schema instance.
      */
@@ -812,31 +812,54 @@ export default class Schema extends ObservableMixin() {
         this._compiledDefinitions = null;
     }
     _compile() {
-        const compiledDefinitions = {};
+        const definitions = {};
         const sourceRules = this._sourceDefinitions;
         const itemNames = Object.keys(sourceRules);
         for (const itemName of itemNames) {
-            compiledDefinitions[itemName] = compileBaseItemRule(sourceRules[itemName], itemName);
+            definitions[itemName] = compileBaseItemRule(sourceRules[itemName], itemName);
         }
-        for (const itemName of itemNames) {
-            compileAllowChildren(compiledDefinitions, itemName);
+        const items = Object.values(definitions);
+        // Sometimes features add rules (allows, disallows) for items that has not been registered yet. We allow that, to make it easier
+        // to put the schema together. However, sometimes these items are never registered. To prevent operating
+        // removeUnregisteredEntries( definitions, items );
+        // 1. Propagate `childItem.allowIn` to `parentItem.allowChildren` and vice versa, so that these properties are completely mirrored
+        // for all children and parents. Do the same for `disallowIn` and `disallowChildren`.
+        for (const item of items) {
+            propagateAllowIn(definitions, item);
+            propagateAllowChildren(definitions, item);
+            propagateDisallowIn(definitions, item);
+            propagateDisallowChildren(definitions, item);
         }
-        for (const itemName of itemNames) {
-            compileAllowContentOf(compiledDefinitions, itemName);
+        // 2. Remove from `allowIn` and `allowChildren` these items which where disallowed by `disallowIn` and `disallowChildren`.
+        // Do the same for attributes. Now we have a clear situation where which item/attribute is allowed. Inheritance is in next steps.
+        for (const item of items) {
+            resolveDisallows(definitions, item);
         }
-        for (const itemName of itemNames) {
-            compileAllowWhere(compiledDefinitions, itemName);
+        // 3. Compile `item.allowContentOf` property. For each entry in `allowContentOf`, we want to take `allowChildren` and rewrite
+        // them into `item.allowChildren`. `item.disallowChildren` is used to filter out some entries. This way "own rules" have higher
+        // priority than "inherited rules". Mirroring from step 1. is maintained.
+        for (const item of items) {
+            compileAllowContentOf(definitions, item);
         }
-        for (const itemName of itemNames) {
-            compileAllowAttributesOf(compiledDefinitions, itemName);
-            compileInheritPropertiesFrom(compiledDefinitions, itemName);
+        // 4. Compile `item.allowWhere` property. For each entry in `allowWhere`, we want to take `allowIn` and rewrite them into
+        // `item.allowIn`. `item.disallowIn` is used to filter out some entries. This way "own rules" have higher priority than
+        // "inherited rules". Mirroring from step 1. is maintained.
+        for (const item of items) {
+            compileAllowWhere(definitions, item);
         }
-        for (const itemName of itemNames) {
-            cleanUpAllowIn(compiledDefinitions, itemName);
-            setupAllowChildren(compiledDefinitions, itemName);
-            cleanUpAllowAttributes(compiledDefinitions, itemName);
+        // 5. Compile `item.allowAttributesOf`. For each entry in `allowAttributesOf`, we want to take `allowAttributes` and rewrite them
+        // into `item.allowAttributes`. `item.disallowAttributes` is used to filter out some entries. This way "own rules" have higher
+        // priority than "inherited rules".
+        for (const item of items) {
+            compileAllowAttributesOf(definitions, item);
+        }
+        // 6. Compile `item.inheritTypesFrom` property. For each entry in `inheritTypesFrom`, we want to take `is*` properties and
+        // set them on `item` (if they are not set yet).
+        for (const item of items) {
+            compileInheritPropertiesFrom(definitions, item);
         }
-        this._compiledDefinitions = compiledDefinitions;
+        // Compile final definitions. Unnecessary properties are removed and some additional cleaning is applied.
+        this._compiledDefinitions = compileDefinitions(definitions);
     }
     _checkContextMatch(def, context, contextItemIndex = context.length - 1) {
         const contextItem = context.getItem(contextItemIndex);
@@ -1073,76 +1096,185 @@ export class SchemaContext {
 function compileBaseItemRule(sourceItemRules, itemName) {
     const itemRule = {
         name: itemName,
-        allowIn: [],
-        allowContentOf: [],
-        allowWhere: [],
-        allowAttributes: [],
-        allowAttributesOf: [],
-        allowChildren: [],
-        inheritTypesFrom: []
+        allowIn: new Set(),
+        allowChildren: new Set(),
+        disallowIn: new Set(),
+        disallowChildren: new Set(),
+        allowContentOf: new Set(),
+        allowWhere: new Set(),
+        allowAttributes: new Set(),
+        disallowAttributes: new Set(),
+        allowAttributesOf: new Set(),
+        inheritTypesFrom: new Set()
     };
     copyTypes(sourceItemRules, itemRule);
     copyProperty(sourceItemRules, itemRule, 'allowIn');
+    copyProperty(sourceItemRules, itemRule, 'allowChildren');
+    copyProperty(sourceItemRules, itemRule, 'disallowIn');
+    copyProperty(sourceItemRules, itemRule, 'disallowChildren');
     copyProperty(sourceItemRules, itemRule, 'allowContentOf');
     copyProperty(sourceItemRules, itemRule, 'allowWhere');
     copyProperty(sourceItemRules, itemRule, 'allowAttributes');
+    copyProperty(sourceItemRules, itemRule, 'disallowAttributes');
     copyProperty(sourceItemRules, itemRule, 'allowAttributesOf');
-    copyProperty(sourceItemRules, itemRule, 'allowChildren');
     copyProperty(sourceItemRules, itemRule, 'inheritTypesFrom');
-    makeInheritAllWork(sourceItemRules, itemRule);
+    resolveInheritAll(sourceItemRules, itemRule);
     return itemRule;
 }
-function compileAllowChildren(compiledDefinitions, itemName) {
-    const item = compiledDefinitions[itemName];
-    for (const allowChildrenItem of item.allowChildren) {
-        const allowedChildren = compiledDefinitions[allowChildrenItem];
-        // The allowChildren property may point to an unregistered element.
-        if (!allowedChildren) {
-            continue;
+function propagateAllowIn(definitions, item) {
+    for (const parentName of item.allowIn) {
+        const parentItem = definitions[parentName];
+        if (parentItem) {
+            parentItem.allowChildren.add(item.name);
+        }
+        else {
+            item.allowIn.delete(parentName);
         }
-        allowedChildren.allowIn.push(itemName);
     }
-    // The allowIn property already includes correct items, reset the allowChildren property
-    // to avoid duplicates later when setting up compilation results.
-    item.allowChildren.length = 0;
 }
-function compileAllowContentOf(compiledDefinitions, itemName) {
-    for (const allowContentOfItemName of compiledDefinitions[itemName].allowContentOf) {
-        // The allowContentOf property may point to an unregistered element.
-        if (compiledDefinitions[allowContentOfItemName]) {
-            const allowedChildren = getAllowedChildren(compiledDefinitions, allowContentOfItemName);
-            allowedChildren.forEach(allowedItem => {
-                allowedItem.allowIn.push(itemName);
-            });
+function propagateAllowChildren(definitions, item) {
+    for (const childName of item.allowChildren) {
+        const childItem = definitions[childName];
+        if (childItem) {
+            childItem.allowIn.add(item.name);
+        }
+        else {
+            item.allowChildren.delete(childName);
         }
     }
-    delete compiledDefinitions[itemName].allowContentOf;
 }
-function compileAllowWhere(compiledDefinitions, itemName) {
-    for (const allowWhereItemName of compiledDefinitions[itemName].allowWhere) {
-        const inheritFrom = compiledDefinitions[allowWhereItemName];
-        // The allowWhere property may point to an unregistered element.
-        if (inheritFrom) {
-            const allowedIn = inheritFrom.allowIn;
-            compiledDefinitions[itemName].allowIn.push(...allowedIn);
+function propagateDisallowIn(definitions, item) {
+    for (const parentName of item.disallowIn) {
+        const parentItem = definitions[parentName];
+        if (parentItem) {
+            parentItem.disallowChildren.add(item.name);
+        }
+        else {
+            item.disallowIn.delete(parentName);
         }
     }
-    delete compiledDefinitions[itemName].allowWhere;
 }
-function compileAllowAttributesOf(compiledDefinitions, itemName) {
-    for (const allowAttributeOfItem of compiledDefinitions[itemName].allowAttributesOf) {
-        const inheritFrom = compiledDefinitions[allowAttributeOfItem];
-        if (inheritFrom) {
-            const inheritAttributes = inheritFrom.allowAttributes;
-            compiledDefinitions[itemName].allowAttributes.push(...inheritAttributes);
+function propagateDisallowChildren(definitions, item) {
+    for (const childName of item.disallowChildren) {
+        const childItem = definitions[childName];
+        if (childItem) {
+            childItem.disallowIn.add(item.name);
+        }
+        else {
+            item.disallowChildren.delete(childName);
+        }
+    }
+}
+function resolveDisallows(definitions, item) {
+    for (const childName of item.disallowChildren) {
+        item.allowChildren.delete(childName);
+    }
+    for (const parentName of item.disallowIn) {
+        item.allowIn.delete(parentName);
+    }
+    for (const attributeName of item.disallowAttributes) {
+        item.allowAttributes.delete(attributeName);
+    }
+}
+function compileAllowContentOf(definitions, item) {
+    for (const allowContentOfItemName of item.allowContentOf) {
+        const baseItem = definitions[allowContentOfItemName];
+        if (!baseItem) {
+            continue;
+        }
+        // Copy `disallowChildren` to propagate this "knowledge" down the inheritance chain. The inheritance may involve multiple items and
+        // if this is not propagated, then items down the chain may start to allow for items that were disallowed by previous base items.
+        //
+        // The scenarios were it is important involves multiple inherits both on parent items side and on the child items side.
+        baseItem.disallowChildren.forEach(childName => {
+            // Own item's rules takes precedence before inherited.
+            // If the item directly allows for given child, ignore that base item disallowed that child.
+            if (item.allowChildren.has(childName)) {
+                return;
+            }
+            item.disallowChildren.add(childName);
+            definitions[childName].disallowIn.add(item.name);
+        });
+        // Copy `allowChildren` from the base item to allow for the same items.
+        baseItem.allowChildren.forEach(childName => {
+            // Own item's rules takes precedence before inherited.
+            // Also, `item.disallowChildren` might get some new items during inheritance process.
+            if (item.disallowChildren.has(childName)) {
+                return;
+            }
+            item.allowChildren.add(childName);
+            definitions[childName].allowIn.add(item.name);
+        });
+    }
+}
+function compileAllowWhere(definitions, item) {
+    for (const allowWhereItemName of item.allowWhere) {
+        const baseItem = definitions[allowWhereItemName];
+        if (!baseItem) {
+            continue;
         }
+        // Copy `disallowIn` to propagate this "knowledge" down the inheritance chain. The inheritance may involve multiple items and
+        // if this is not propagated, then items down the chain may start to be allowed in items in which they were disallowed previously.
+        //
+        // The scenarios were it is important involves multiple inherits both on parent items side and on the child items side.
+        baseItem.disallowIn.forEach(parentName => {
+            // Own item's rules takes precedence before inherited.
+            // If the item is directly allowed in given parent, ignore that base item was disallowed in it.
+            if (item.allowIn.has(parentName)) {
+                return;
+            }
+            item.disallowIn.add(parentName);
+            definitions[parentName].disallowChildren.add(item.name);
+        });
+        // Copy `allowIn` from the base item to allow item in same parents.
+        baseItem.allowIn.forEach(parentName => {
+            // Own item's rules takes precedence before inherited.
+            // Also, `item.disallowIn` might get some new items during inheritance process.
+            if (item.disallowIn.has(parentName)) {
+                return;
+            }
+            item.allowIn.add(parentName);
+            definitions[parentName].allowChildren.add(item.name);
+        });
     }
-    delete compiledDefinitions[itemName].allowAttributesOf;
 }
-function compileInheritPropertiesFrom(compiledDefinitions, itemName) {
-    const item = compiledDefinitions[itemName];
-    for (const inheritPropertiesOfItem of item.inheritTypesFrom) {
-        const inheritFrom = compiledDefinitions[inheritPropertiesOfItem];
+function compileDefinitions(definitions) {
+    const finalDefinitions = {};
+    for (const item of Object.values(definitions)) {
+        finalDefinitions[item.name] = {
+            name: item.name,
+            // `is*` properties may not be set - convert `undefined` to `false`.
+            isBlock: !!item.isBlock,
+            isContent: !!item.isContent,
+            isInline: !!item.isInline,
+            isLimit: !!item.isLimit,
+            isObject: !!item.isObject,
+            isSelectable: !!item.isSelectable,
+            // Filter out non-existing items.
+            allowIn: Array.from(item.allowIn).filter(name => !!definitions[name]),
+            allowChildren: Array.from(item.allowChildren).filter(name => !!definitions[name]),
+            allowAttributes: Array.from(item.allowAttributes)
+        };
+    }
+    return finalDefinitions;
+}
+function compileAllowAttributesOf(definitions, item) {
+    for (const allowAttributeOfItemName of item.allowAttributesOf) {
+        const baseItem = definitions[allowAttributeOfItemName];
+        if (!baseItem) {
+            return;
+        }
+        baseItem.allowAttributes.forEach(attributeName => {
+            if (item.disallowAttributes.has(attributeName)) {
+                return;
+            }
+            item.allowAttributes.add(attributeName);
+        });
+    }
+}
+function compileInheritPropertiesFrom(definitions, item) {
+    for (const inheritPropertiesOfItemName of item.inheritTypesFrom) {
+        const inheritFrom = definitions[inheritPropertiesOfItemName];
         if (inheritFrom) {
             const typeNames = Object.keys(inheritFrom).filter(name => name.startsWith('is'));
             for (const name of typeNames) {
@@ -1152,26 +1284,6 @@ function compileInheritPropertiesFrom(compiledDefinitions, itemName) {
             }
         }
     }
-    delete item.inheritTypesFrom;
-}
-// Remove items which weren't registered (because it may break some checks or we'd need to complicate them).
-// Make sure allowIn doesn't contain repeated values.
-function cleanUpAllowIn(compiledDefinitions, itemName) {
-    const itemRule = compiledDefinitions[itemName];
-    const existingItems = itemRule.allowIn.filter(itemToCheck => compiledDefinitions[itemToCheck]);
-    itemRule.allowIn = Array.from(new Set(existingItems));
-}
-// Setup allowChildren items based on allowIn.
-function setupAllowChildren(compiledDefinitions, itemName) {
-    const itemRule = compiledDefinitions[itemName];
-    for (const allowedParentItemName of itemRule.allowIn) {
-        const allowedParentItem = compiledDefinitions[allowedParentItemName];
-        allowedParentItem.allowChildren.push(itemName);
-    }
-}
-function cleanUpAllowAttributes(compiledDefinitions, itemName) {
-    const itemRule = compiledDefinitions[itemName];
-    itemRule.allowAttributes = Array.from(new Set(itemRule.allowAttributes));
 }
 function copyTypes(sourceItemRules, itemRule) {
     for (const sourceItemRule of sourceItemRules) {
@@ -1183,33 +1295,28 @@ function copyTypes(sourceItemRules, itemRule) {
 }
 function copyProperty(sourceItemRules, itemRule, propertyName) {
     for (const sourceItemRule of sourceItemRules) {
-        const value = sourceItemRule[propertyName];
+        let value = sourceItemRule[propertyName];
+        // `value` can be a string, an array or undefined.
+        // Convert a string to an array with one item, then handle an array. Skip undefined this way.
         if (typeof value == 'string') {
-            itemRule[propertyName].push(value);
+            value = [value];
         }
-        else if (Array.isArray(value)) {
-            itemRule[propertyName].push(...value);
+        if (Array.isArray(value)) {
+            value.forEach(singleValue => itemRule[propertyName].add(singleValue));
         }
     }
 }
-function makeInheritAllWork(sourceItemRules, itemRule) {
+function resolveInheritAll(sourceItemRules, itemRule) {
     for (const sourceItemRule of sourceItemRules) {
         const inheritFrom = sourceItemRule.inheritAllFrom;
         if (inheritFrom) {
-            itemRule.allowContentOf.push(inheritFrom);
-            itemRule.allowWhere.push(inheritFrom);
-            itemRule.allowAttributesOf.push(inheritFrom);
-            itemRule.inheritTypesFrom.push(inheritFrom);
+            itemRule.allowContentOf.add(inheritFrom);
+            itemRule.allowWhere.add(inheritFrom);
+            itemRule.allowAttributesOf.add(inheritFrom);
+            itemRule.inheritTypesFrom.add(inheritFrom);
         }
     }
 }
-function getAllowedChildren(compiledDefinitions, itemName) {
-    const itemRule = compiledDefinitions[itemName];
-    return getValues(compiledDefinitions).filter(def => def.allowIn.includes(itemRule.name));
-}
-function getValues(obj) {
-    return Object.keys(obj).map(key => obj[key]);
-}
 function mapContextItem(ctxItem) {
     if (typeof ctxItem == 'string' || ctxItem.is('documentFragment')) {
         return {

package/src/model/selection.d.ts

@@ -20,7 +20,7 @@ declare const Selection_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof T
  * Additionally, selection may have its own attributes (think – whether text typed in in this selection
  * should have those attributes – e.g. whether you type a bolded text).
  */
-export default class Selection extends Selection_base {
+export default class Selection extends /* #__PURE__ */ Selection_base {
     /**
      * Specifies whether the last added range was added as a backward or forward range.
      */

package/src/model/selection.js

@@ -17,7 +17,7 @@ import { CKEditorError, EmitterMixin, isIterable } from '@ckeditor/ckeditor5-uti
  * Additionally, selection may have its own attributes (think – whether text typed in in this selection
  * should have those attributes – e.g. whether you type a bolded text).
  */
-export default class Selection extends EmitterMixin(TypeCheckable) {
+export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
     /**
      * Creates a new selection instance based on the given {@link module:engine/model/selection~Selectable selectable}
      * or creates an empty selection if no arguments were passed.

package/src/view/document.d.ts

@@ -18,7 +18,7 @@ declare const Document_base: import("@ckeditor/ckeditor5-utils").Mixed<{
  * Document class creates an abstract layer over the content editable area, contains a tree of view elements and
  * {@link module:engine/view/documentselection~DocumentSelection view selection} associated with this document.
  */
-export default class Document extends Document_base {
+export default class Document extends /* #__PURE__ */ Document_base {
     /**
      * Selection done on this document.
      */

package/src/view/document.js

@@ -13,7 +13,7 @@ import { Collection, ObservableMixin } from '@ckeditor/ckeditor5-utils';
  * Document class creates an abstract layer over the content editable area, contains a tree of view elements and
  * {@link module:engine/view/documentselection~DocumentSelection view selection} associated with this document.
  */
-export default class Document extends BubblingEmitterMixin(ObservableMixin()) {
+export default class Document extends /* #__PURE__ */ BubblingEmitterMixin(/* #__PURE__ */ ObservableMixin()) {
     /**
      * Creates a Document instance.
      *

package/src/view/documentfragment.d.ts

@@ -17,7 +17,7 @@ declare const DocumentFragment_base: import("@ckeditor/ckeditor5-utils").Mixed<t
  * {@link module:engine/view/upcastwriter~UpcastWriter#createDocumentFragment `UpcastWriter#createDocumentFragment()`}
  * method.
  */
-export default class DocumentFragment extends DocumentFragment_base implements Iterable<Node> {
+export default class DocumentFragment extends /* #__PURE__ */ DocumentFragment_base implements Iterable<Node> {
     /**
      * The document to which this document fragment belongs.
      */

package/src/view/documentfragment.js

@@ -16,7 +16,7 @@ import { EmitterMixin, isIterable } from '@ckeditor/ckeditor5-utils';
  * {@link module:engine/view/upcastwriter~UpcastWriter#createDocumentFragment `UpcastWriter#createDocumentFragment()`}
  * method.
  */
-export default class DocumentFragment extends EmitterMixin(TypeCheckable) {
+export default class DocumentFragment extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
     /**
      * Creates new DocumentFragment instance.
      *

package/src/view/documentselection.d.ts

@@ -24,7 +24,7 @@ declare const DocumentSelection_base: import("@ckeditor/ckeditor5-utils").Mixed<
  * the {@link module:engine/view/view~View#change `View#change()`} block
  * (so via {@link module:engine/view/downcastwriter~DowncastWriter#setSelection `DowncastWriter#setSelection()`}).
  */
-export default class DocumentSelection extends DocumentSelection_base {
+export default class DocumentSelection extends /* #__PURE__ */ DocumentSelection_base {
     /**
      * Selection is used internally (`DocumentSelection` is a proxy to that selection).
      */

package/src/view/documentselection.js

@@ -18,7 +18,7 @@ import { EmitterMixin } from '@ckeditor/ckeditor5-utils';
  * the {@link module:engine/view/view~View#change `View#change()`} block
  * (so via {@link module:engine/view/downcastwriter~DowncastWriter#setSelection `DowncastWriter#setSelection()`}).
  */
-export default class DocumentSelection extends EmitterMixin(TypeCheckable) {
+export default class DocumentSelection extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
     constructor(...args) {
         super();
         this._selection = new Selection();