ckeditor5-elements-schema 0.0.0-stage → 49.0.0-alpha.4

package/dist/conversion/inlineTextElement.d.ts

@@ -0,0 +1,24 @@
+import type { ViewContainerElement, ViewDowncastWriter } from 'ckeditor5';
+/**
+ * Makes a view element have no block filler, and returns it: for the view of an inline element with text, e.g. a bold
+ * that is an element, so that the cursor can go in it when it is empty.
+ *
+ * CKEditor puts a block filler, a `<br>`, in an empty container element, so that an empty paragraph has a height. In an
+ * inline element, the browser does not type there: the text goes before the element. Without the block filler, CKEditor
+ * puts its inline filler where the cursor is, as in the empty `<strong>` of its own bold, and the text goes in.
+ *
+ * ```ts
+ * conversion.for('downcast').elementToElement({
+ *   model: 'bold',
+ *   view: (element, { writer }) => withoutBlockFiller(writer.createContainerElement('strong'))
+ * });
+ * ```
+ *
+ * The converters of the element schema (`elementSchemaConverters`) and the `view` of `ElementSchemaCommands` do it already.
+ */
+export declare function withoutBlockFiller<T extends ViewContainerElement>(element: T): T;
+/**
+ * Creates the view of an inline element with text: an element with no block filler (see {@link withoutBlockFiller}).
+ */
+export declare function createInlineTextElement(writer: ViewDowncastWriter, tag: string, name?: string): ViewContainerElement;
+//# sourceMappingURL=inlineTextElement.d.ts.map

package/dist/conversion/inlineTextElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineTextElement.d.ts","sourceRoot":"","sources":["../../src/conversion/inlineTextElement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE1E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,oBAAoB,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAIhF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,oBAAoB,CAEpH"}

package/dist/conversion/inlineTextElement.js

@@ -0,0 +1,28 @@
+/**
+ * Makes a view element have no block filler, and returns it: for the view of an inline element with text, e.g. a bold
+ * that is an element, so that the cursor can go in it when it is empty.
+ *
+ * CKEditor puts a block filler, a `<br>`, in an empty container element, so that an empty paragraph has a height. In an
+ * inline element, the browser does not type there: the text goes before the element. Without the block filler, CKEditor
+ * puts its inline filler where the cursor is, as in the empty `<strong>` of its own bold, and the text goes in.
+ *
+ * ```ts
+ * conversion.for('downcast').elementToElement({
+ *   model: 'bold',
+ *   view: (element, { writer }) => withoutBlockFiller(writer.createContainerElement('strong'))
+ * });
+ * ```
+ *
+ * The converters of the element schema (`elementSchemaConverters`) and the `view` of `ElementSchemaCommands` do it already.
+ */
+export function withoutBlockFiller(element) {
+    element.getFillerOffset = () => null;
+    return element;
+}
+/**
+ * Creates the view of an inline element with text: an element with no block filler (see {@link withoutBlockFiller}).
+ */
+export function createInlineTextElement(writer, tag, name) {
+    return withoutBlockFiller(writer.createContainerElement(tag, name ? { class: name } : {}));
+}
+//# sourceMappingURL=inlineTextElement.js.map

package/dist/conversion/inlineTextElement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineTextElement.js","sourceRoot":"","sources":["../../src/conversion/inlineTextElement.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB,CAAiC,OAAU;IAC5E,OAAO,CAAC,eAAe,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC;IAErC,OAAO,OAAO,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAA0B,EAAE,GAAW,EAAE,IAAa;IAC7F,OAAO,kBAAkB,CAAC,MAAM,CAAC,sBAAsB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5F,CAAC"}

package/dist/definition/canHold.d.ts

@@ -0,0 +1,10 @@
+import type { ElementSchemaKind } from './types.js';
+/**
+ * The root can hold blocks, containers and block-level empty elements, like a container.
+ */
+export declare const ROOT: ElementSchemaKind;
+/**
+ * Returns why `parent` cannot contain `child` (an element, or `'$text'`), or `null` when it can.
+ */
+export declare function whyNot(parent: ElementSchemaKind, child: ElementSchemaKind | '$text'): string | null;
+//# sourceMappingURL=canHold.d.ts.map

package/dist/definition/canHold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canHold.d.ts","sourceRoot":"","sources":["../../src/definition/canHold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,iBAA0D,CAAC;AAE9E;;GAEG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBnG"}

package/dist/definition/canHold.js

@@ -0,0 +1,22 @@
+/**
+ * The root can hold blocks, containers and block-level empty elements, like a container.
+ */
+export const ROOT = { type: 'container', isInline: false };
+/**
+ * Returns why `parent` cannot contain `child` (an element, or `'$text'`), or `null` when it can.
+ */
+export function whyNot(parent, child) {
+    const isText = child === '$text';
+    if (parent.type === 'empty') {
+        return 'an empty element cannot contain anything';
+    }
+    if (parent.type === 'block') {
+        const what = parent.isInline ? 'an inline text element' : 'a block';
+        return isText || child.isInline ? null : `${what} can contain only text and inline elements`;
+    }
+    if (isText) {
+        return 'a container cannot contain text: put the text in a block';
+    }
+    return child.isInline ? 'a container cannot contain inline elements: put them in a block' : null;
+}
+//# sourceMappingURL=canHold.js.map

package/dist/definition/canHold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canHold.js","sourceRoot":"","sources":["../../src/definition/canHold.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAsB,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAE9E;;GAEG;AACH,MAAM,UAAU,MAAM,CAAC,MAAyB,EAAE,KAAkC;IACnF,MAAM,MAAM,GAAG,KAAK,KAAK,OAAO,CAAC;IAEjC,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,OAAO,0CAA0C,CAAC;IACnD,CAAC;IAED,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,SAAS,CAAC;QAEpE,OAAO,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,4CAA4C,CAAC;IAC9F,CAAC;IAED,IAAI,MAAM,EAAE,CAAC;QACZ,OAAO,0DAA0D,CAAC;IACnE,CAAC;IAED,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,iEAAiE,CAAC,CAAC,CAAC,IAAI,CAAC;AAClG,CAAC"}

package/dist/definition/compileElementSchema.d.ts

@@ -0,0 +1,41 @@
+import type { ModelSchemaItemDefinition } from 'ckeditor5';
+import type { ElementSchemaInput } from './types.js';
+/**
+ * The result of {@link compileElementSchema}.
+ */
+export interface CompiledElementSchema {
+    /**
+     * The items to register in CKEditor's schema, by name.
+     */
+    items: [name: string, definition: ModelSchemaItemDefinition][];
+    /**
+     * The `allowChildren` of the elements, as the places to add to the children: `schema.extend(child, { allowIn: parent })`.
+     * The child can be an element of another plugin, which is extended, not registered.
+     */
+    children: {
+        parent: string;
+        child: string;
+    }[];
+}
+/**
+ * Translates a valid element schema to the definitions of CKEditor's schema. Each type is made like a generic item of
+ * CKEditor:
+ *
+ * * `container`: like `$container`: allowed in the root and in containers; holds what is allowed in a container: blocks,
+ *   containers and block objects, not text.
+ * * `block`: like `$block`: a block, allowed in the root and in containers; holds text and inline objects.
+ * * `empty` and not inline: like `$blockObject`: an object, allowed where blocks are.
+ * * `empty` and inline: like `$inlineObject`: an object, allowed where text is, with the attributes of text.
+ * * `block` and inline: an inline element that holds text and inline elements, allowed where text is, with the attributes
+ *   of text: like `$text`, but an element, so it can have attributes of its own.
+ * * `container` and inline: a container laid out in a line, e.g. with others in a block: allowed where text is, like every
+ *   inline element, and holds the same as a container: blocks, not text.
+ *
+ * `isInline` is about the layout and the position of an element, so it is set for every type, and CKEditor's features and
+ * the converters can use it.
+ *
+ * `allowAttributes` is passed as it is. `allowIn` replaces the default places of the type. `allowChildren` adds to what
+ * the type holds, as in CKEditor.
+ */
+export declare function compileElementSchema(input: ElementSchemaInput): CompiledElementSchema;
+//# sourceMappingURL=compileElementSchema.d.ts.map

package/dist/definition/compileElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileElementSchema.d.ts","sourceRoot":"","sources":["../../src/definition/compileElementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAwB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,yBAAyB,CAAC,EAAE,CAAC;IAE/D;;;OAGG;IACH,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,GAAG,qBAAqB,CAarF"}

package/dist/definition/compileElementSchema.js

@@ -0,0 +1,60 @@
+/**
+ * Translates a valid element schema to the definitions of CKEditor's schema. Each type is made like a generic item of
+ * CKEditor:
+ *
+ * * `container`: like `$container`: allowed in the root and in containers; holds what is allowed in a container: blocks,
+ *   containers and block objects, not text.
+ * * `block`: like `$block`: a block, allowed in the root and in containers; holds text and inline objects.
+ * * `empty` and not inline: like `$blockObject`: an object, allowed where blocks are.
+ * * `empty` and inline: like `$inlineObject`: an object, allowed where text is, with the attributes of text.
+ * * `block` and inline: an inline element that holds text and inline elements, allowed where text is, with the attributes
+ *   of text: like `$text`, but an element, so it can have attributes of its own.
+ * * `container` and inline: a container laid out in a line, e.g. with others in a block: allowed where text is, like every
+ *   inline element, and holds the same as a container: blocks, not text.
+ *
+ * `isInline` is about the layout and the position of an element, so it is set for every type, and CKEditor's features and
+ * the converters can use it.
+ *
+ * `allowAttributes` is passed as it is. `allowIn` replaces the default places of the type. `allowChildren` adds to what
+ * the type holds, as in CKEditor.
+ */
+export function compileElementSchema(input) {
+    const items = [];
+    const children = [];
+    for (const [name, element] of Object.entries(input)) {
+        items.push([name, compileElement(element)]);
+        for (const child of element.allowChildren ?? []) {
+            children.push({ parent: name, child });
+        }
+    }
+    return { items, children };
+}
+function compileElement({ type, isInline, allowIn, allowAttributes }) {
+    // Where the element is allowed: the places of its type, or the given ones.
+    const places = (defaultPlaces) => allowIn ? { allowIn } : { allowWhere: defaultPlaces };
+    const attributes = allowAttributes ? { allowAttributes } : {};
+    if (type === 'empty' && isInline) {
+        return { inheritTypesFrom: '$inlineObject', allowAttributesOf: '$text', ...places('$text'), ...attributes };
+    }
+    if (type === 'empty') {
+        return { inheritTypesFrom: '$blockObject', ...places('$block'), ...attributes };
+    }
+    if (type === 'block' && isInline) {
+        return {
+            isInline: true,
+            allowContentOf: '$block',
+            allowAttributesOf: '$text',
+            ...places('$text'),
+            ...attributes
+        };
+    }
+    if (type === 'block') {
+        return { inheritTypesFrom: '$block', allowContentOf: '$block', ...places('$block'), ...attributes };
+    }
+    return {
+        allowContentOf: '$container',
+        ...(isInline ? { isInline: true, ...places('$text') } : places('$block')),
+        ...attributes
+    };
+}
+//# sourceMappingURL=compileElementSchema.js.map

package/dist/definition/compileElementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileElementSchema.js","sourceRoot":"","sources":["../../src/definition/compileElementSchema.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAyB;IAC7D,MAAM,KAAK,GAAmC,EAAE,CAAC;IACjD,MAAM,QAAQ,GAAsC,EAAE,CAAC;IAEvD,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,cAAc,CAAC,OAA+B,CAAC,CAAC,CAAC,CAAC;QAEpE,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,aAAa,IAAI,EAAE,EAAE,CAAC;YACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACxC,CAAC;IACF,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,cAAc,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAwB;IACzF,2EAA2E;IAC3E,MAAM,MAAM,GAAG,CAAC,aAAqB,EAA6D,EAAE,CACnG,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;IACvD,MAAM,UAAU,GAAG,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAE9D,IAAI,IAAI,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC;QAClC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IAC7G,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACtB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IACjF,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC;QAClC,OAAO;YACN,QAAQ,EAAE,IAAI;YACd,cAAc,EAAE,QAAQ;YACxB,iBAAiB,EAAE,OAAO;YAC1B,GAAG,MAAM,CAAC,OAAO,CAAC;YAClB,GAAG,UAAU;SACb,CAAC;IACH,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACtB,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IACrG,CAAC;IAED,OAAO;QACN,cAAc,EAAE,YAAY;QAC5B,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzE,GAAG,UAAU;KACb,CAAC;AACH,CAAC"}

package/dist/definition/elementSchemaError.d.ts

@@ -0,0 +1,12 @@
+import type { ElementSchemaIssue } from './types.js';
+/**
+ * Thrown when the element schema is not valid. It lists all the problems, and has them in {@link issues}.
+ */
+export default class ElementSchemaError extends Error {
+    /**
+     * The problems of the schema.
+     */
+    readonly issues: readonly ElementSchemaIssue[];
+    constructor(issues: readonly ElementSchemaIssue[]);
+}
+//# sourceMappingURL=elementSchemaError.d.ts.map

package/dist/definition/elementSchemaError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaError.d.ts","sourceRoot":"","sources":["../../src/definition/elementSchemaError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,KAAK;IACpD;;OAEG;IACH,SAAgB,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;gBAE1C,MAAM,EAAE,SAAS,kBAAkB,EAAE;CASjD"}

package/dist/definition/elementSchemaError.js

@@ -0,0 +1,16 @@
+/**
+ * Thrown when the element schema is not valid. It lists all the problems, and has them in {@link issues}.
+ */
+export default class ElementSchemaError extends Error {
+    /**
+     * The problems of the schema.
+     */
+    issues;
+    constructor(issues) {
+        super(`The element schema is not valid (${String(issues.length)} ${issues.length === 1 ? 'problem' : 'problems'}):\n` +
+            issues.map(({ path, message }) => `- ${path ? `${path}: ` : ''}${message}`).join('\n'));
+        this.name = 'ElementSchemaError';
+        this.issues = issues;
+    }
+}
+//# sourceMappingURL=elementSchemaError.js.map

package/dist/definition/elementSchemaError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaError.js","sourceRoot":"","sources":["../../src/definition/elementSchemaError.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,KAAK;IACpD;;OAEG;IACa,MAAM,CAAgC;IAEtD,YAAY,MAAqC;QAChD,KAAK,CACJ,oCAAoC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,MAAM;YAC9G,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACvF,CAAC;QAEF,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACtB,CAAC;CACD"}

package/dist/definition/readDefinition.d.ts

@@ -0,0 +1,18 @@
+import type { ElementSchemaKind } from './types.js';
+/**
+ * Reports a problem of the schema, at the path.
+ */
+export type Report = (path: string, message: string) => void;
+export declare const ELEMENT_KEYS: string[];
+export declare const ELEMENT_NAME: RegExp;
+export declare const ATTRIBUTE_NAME: RegExp;
+export declare const TAG_NAME: RegExp;
+export declare function readKind(definition: Record<string, unknown>, path: string, report: Report): ElementSchemaKind | null;
+/**
+ * Reads a list of names, and reports what is not a list of unique, non-empty strings. Returns the list, or
+ * `undefined` when it is missing.
+ */
+export declare function readNames(definition: Record<string, unknown>, key: string, path: string, report: Report): string[] | undefined;
+export declare function checkKeys(object: Record<string, unknown>, allowed: readonly string[], path: string, report: Report): void;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=readDefinition.d.ts.map

package/dist/definition/readDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDefinition.d.ts","sourceRoot":"","sources":["../../src/definition/readDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAG7D,eAAO,MAAM,YAAY,UAAoF,CAAC;AAE9G,eAAO,MAAM,YAAY,QAAwB,CAAC;AAClD,eAAO,MAAM,cAAc,QAAuB,CAAC;AACnD,eAAO,MAAM,QAAQ,QAAkC,CAAC;AAExD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAuBpH;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACZ,MAAM,EAAE,GAAG,SAAS,CA4BtB;AAED,wBAAgB,SAAS,CACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACZ,IAAI,CASN;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/dist/definition/readDefinition.js

@@ -0,0 +1,60 @@
+import { suggest } from './suggest.js';
+const TYPES = ['empty', 'block', 'container'];
+export const ELEMENT_KEYS = ['type', 'isInline', 'allowChildren', 'allowIn', 'allowAttributes', 'editingTag'];
+export const ELEMENT_NAME = /^[a-z][A-Za-z0-9]*$/;
+export const ATTRIBUTE_NAME = /^[A-Za-z][\w.:-]*$/;
+export const TAG_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+export function readKind(definition, path, report) {
+    const { type, isInline } = definition;
+    if (isInline !== undefined && typeof isInline !== 'boolean') {
+        report(`${path}.isInline`, 'must be true or false.');
+    }
+    if (type === undefined) {
+        report(`${path}.type`, 'is required: "empty", "block" or "container".');
+        return null;
+    }
+    if (typeof type !== 'string' || !TYPES.includes(type)) {
+        report(`${path}.type`, `must be "empty", "block" or "container", not ${JSON.stringify(type)}${typeof type === 'string' ? suggest(type, TYPES) : ''}.`);
+        return null;
+    }
+    return { type: type, isInline: isInline === true };
+}
+/**
+ * Reads a list of names, and reports what is not a list of unique, non-empty strings. Returns the list, or
+ * `undefined` when it is missing.
+ */
+export function readNames(definition, key, path, report) {
+    const value = definition[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        report(`${path}.${key}`, `must be an array of names, e.g. ["a", "b"].`);
+        return undefined;
+    }
+    const names = [];
+    value.forEach((item, index) => {
+        const itemPath = `${path}.${key}[${String(index)}]`;
+        if (typeof item !== 'string' || !item) {
+            report(itemPath, 'must be a non-empty string.');
+        }
+        else if (names.includes(item)) {
+            report(itemPath, `"${item}" is listed twice.`);
+        }
+        else {
+            names.push(item);
+        }
+    });
+    return names;
+}
+export function checkKeys(object, allowed, path, report) {
+    for (const key of Object.keys(object)) {
+        if (!allowed.includes(key)) {
+            report(path ? `${path}.${key}` : key, `is not a known key${suggest(key, allowed)}. The keys are: ${allowed.map(name => `"${name}"`).join(', ')}.`);
+        }
+    }
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=readDefinition.js.map

package/dist/definition/readDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDefinition.js","sourceRoot":"","sources":["../../src/definition/readDefinition.ts"],"names":[],"mappings":"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"}

package/dist/definition/suggest.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns ` Did you mean "x"?` for the closest candidate, when it is close enough to be a typo.
+ */
+export declare function suggest(name: string, candidates: readonly string[]): string;
+//# sourceMappingURL=suggest.d.ts.map

package/dist/definition/suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../../src/definition/suggest.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAc3E"}

package/dist/definition/suggest.js

@@ -0,0 +1,27 @@
+/**
+ * Returns ` Did you mean "x"?` for the closest candidate, when it is close enough to be a typo.
+ */
+export function suggest(name, candidates) {
+    let best;
+    let bestDistance = 3;
+    for (const candidate of candidates) {
+        const distance = editDistance(name.toLowerCase(), candidate.toLowerCase());
+        if (distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    return best ? ` (did you mean "${best}"?)` : '';
+}
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            current[j] = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length] ?? 0;
+}
+//# sourceMappingURL=suggest.js.map

package/dist/definition/suggest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.js","sourceRoot":"","sources":["../../src/definition/suggest.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,UAA6B;IAClE,IAAI,IAAwB,CAAC;IAC7B,IAAI,YAAY,GAAG,CAAC,CAAC;IAErB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;QAE3E,IAAI,QAAQ,GAAG,YAAY,EAAE,CAAC;YAC7B,IAAI,GAAG,SAAS,CAAC;YACjB,YAAY,GAAG,QAAQ,CAAC;QACzB,CAAC;IACF,CAAC;IAED,OAAO,IAAI,CAAC,CAAC,CAAC,mBAAmB,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACjD,CAAC;AAED,SAAS,YAAY,CAAC,CAAS,EAAE,CAAS;IACzC,IAAI,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAEzE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;QAEpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CACpB,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EACtB,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EACzB,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACxD,CAAC;QACH,CAAC;QAED,QAAQ,GAAG,OAAO,CAAC;IACpB,CAAC;IAED,OAAO,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/definition/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The kinds of elements of an element schema:
+ *
+ * * `empty`: has no content, like an image or a line break. It is an object: selected as a whole.
+ * * `block`: can contain text and inline elements, like a paragraph or a heading. With `isInline`, it is an inline
+ *   element with text, like a bold with an `id`.
+ *
+ * * `container`: cannot contain text; holds blocks, empty block elements and other containers, like a block quote or a
+ *   note.
+ *
+ * Every type can be inline (see {@link ElementSchemaElement#isInline}): the type says what the element holds, `isInline`
+ * where and how it is laid out. Inline elements are allowed only in blocks.
+ */
+export type ElementSchemaType = 'empty' | 'block' | 'container';
+/**
+ * The kind of an element: what it is, and whether it is inline: laid out in a line with its siblings, instead of on a
+ * line of its own. Any type can be inline.
+ */
+export interface ElementSchemaKind {
+    type: ElementSchemaType;
+    isInline: boolean;
+}
+/**
+ * The definition of one element of an element schema.
+ */
+export interface ElementSchemaElement {
+    /**
+     * What the element is: `'empty'`, `'block'` or `'container'`.
+     */
+    type: ElementSchemaType;
+    /**
+     * Whether the element is inline: it is about the position and the layout of the element, not about text. An inline
+     * element is laid out in a line with its siblings, where a block-level one has a line of its own. Any type can be:
+     *
+     * * `empty`: like an inline image, or a line break;
+     * * `block`: an element with text in a line of text, like a bold that is an element, with attributes;
+     * * `container`: a box that is not typable, in a line with other boxes, e.g. several in a block.
+     *
+     * Inline elements are allowed only in blocks: by default, where text is. A block holds text and any number of inline
+     * elements; containers and the root hold no inline elements. Default: `false`.
+     */
+    isInline?: boolean;
+    /**
+     * The elements allowed inside this one, in addition to what its type allows: names of elements of the schema, or of
+     * elements of other plugins, and `'$text'`. As in CKEditor's `allowChildren`.
+     *
+     * What a type allows by default: a `block` has text and inline elements; a `container` has blocks, containers and
+     * `empty` block-level elements.
+     */
+    allowChildren?: string[];
+    /**
+     * The elements this one is allowed in, in addition to what its type allows: names of elements, and `'$root'`. As in
+     * CKEditor's `allowIn`.
+     *
+     * Unlike in CKEditor, when it is given it **replaces** the default places (a block-level element is allowed in the
+     * root and in containers; an inline element, where text is), so that an element can be restricted to its parent,
+     * e.g. a row to a table.
+     */
+    allowIn?: string[];
+    /**
+     * The attributes the element can have, as in CKEditor's `allowAttributes`.
+     */
+    allowAttributes?: string[];
+    /**
+     * The tag of the element in the editing view, e.g. `'section'`, when the converters of the schema are on (the
+     * `elementSchemaConverters` option). The data has `div` or `span`, whatever it is. Default: the tag of the data.
+     */
+    editingTag?: string;
+}
+/**
+ * An element schema: the definitions of the elements, by name.
+ */
+export type ElementSchemaDefinition = Record<string, ElementSchemaElement>;
+/**
+ * What the `elementSchema` option accepts: an {@link ElementSchemaDefinition}, or a JSON file imported as it is, whose
+ * strings TypeScript does not know are the allowed ones, and whose arrays are not known to be mutable. Either way, it is
+ * validated when the editor is created.
+ */
+export type ElementSchemaInput = Record<string, {
+    [Key in keyof ElementSchemaElement]: Key extends 'type' ? string : ElementSchemaElement[Key] extends string[] | undefined ? readonly string[] | undefined : ElementSchemaElement[Key];
+}>;
+/**
+ * A problem of an element schema.
+ */
+export interface ElementSchemaIssue {
+    /**
+     * Where the problem is, e.g. `note.allowChildren[1]`.
+     */
+    path: string;
+    /**
+     * What is wrong, and what to do about it.
+     */
+    message: string;
+}
+/**
+ * The options of {@link validateElementSchema}.
+ */
+export interface ValidateElementSchemaOptions {
+    /**
+     * Elements that exist outside the schema, e.g. `paragraph` of the `Paragraph` plugin, by name. The schema can refer to
+     * them, but cannot declare them. Without them, the schema can refer only to its own elements.
+     */
+    external?: Readonly<Record<string, ElementSchemaKind>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/definition/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/definition/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,IAAI,EAAE,iBAAiB,CAAC;IAExB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CACtC,MAAM,EACN;KACE,GAAG,IAAI,MAAM,oBAAoB,GAAG,GAAG,SAAS,MAAM,GACpD,MAAM,GACN,oBAAoB,CAAC,GAAG,CAAC,SAAS,MAAM,EAAE,GAAG,SAAS,GACrD,SAAS,MAAM,EAAE,GAAG,SAAS,GAC7B,oBAAoB,CAAC,GAAG,CAAC;CAC7B,CACD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC5C;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;CACvD"}

package/dist/definition/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/definition/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/definition/types.ts"],"names":[],"mappings":""}

package/dist/definition/validateElementSchema.d.ts

@@ -0,0 +1,26 @@
+import type { ElementSchemaIssue, ValidateElementSchemaOptions } from './types.js';
+/**
+ * Checks an element schema, so that it is not contradictory, and returns the problems. An empty array means that the
+ * schema is valid.
+ *
+ * The schema is rejected when it:
+ *
+ * * is not of the shape {@link ElementSchemaDefinition}: an object of elements, by name; has keys that are not part of
+ *   it (typos are problems), or has values of the wrong type;
+ * * declares an element with an unknown `type`, or an `empty` element with `allowChildren`;
+ * * has attribute names that are not valid, or that differ only in case (HTML attribute names are not case sensitive),
+ *   or an `editingTag` that is not the name of a tag;
+ * * refers to elements that do not exist (a name that is neither declared in the schema, nor in `external`), or lists the
+ *   same name twice;
+ * * allows what its type cannot hold: text or an inline element in a container or in the root, a block-level (not inline)
+ *   element in a block, or anything in an `empty` element, whichever side says it: `allowChildren` of the parent, or
+ *   `allowIn` of the child.
+ *
+ * `isInline` is about the position and the layout of an element, so it is valid for every type: an inline element is
+ * laid out in a line with its siblings. Inline elements are allowed only in blocks, which can hold several of them,
+ * e.g. inline containers, or inline images between text.
+ *
+ * It does not need an editor. The editor of `ElementSchema` runs it with the elements of the other plugins as `external`.
+ */
+export declare function validateElementSchema(input: unknown, { external }?: ValidateElementSchemaOptions): ElementSchemaIssue[];
+//# sourceMappingURL=validateElementSchema.d.ts.map

package/dist/definition/validateElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateElementSchema.d.ts","sourceRoot":"","sources":["../../src/definition/validateElementSchema.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAqB,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,OAAO,EACd,EAAE,QAAa,EAAE,GAAE,4BAAiC,GAClD,kBAAkB,EAAE,CAkKtB"}