@kerebron/extension-tables 0.1.3 → 0.2.0

package/assets/tables.css

@@ -1,26 +1,27 @@
-.ProseMirror .tableWrapper {
+.kb-editor .tableWrapper {
   overflow-x: auto;
 }
-.ProseMirror table {
+.kb-editor table {
   border-collapse: collapse;
   table-layout: fixed;
   width: 100%;
   overflow: hidden;
 }
-.ProseMirror td,
-.ProseMirror th {
+.kb-editor td,
+.kb-editor th {
   vertical-align: top;
   box-sizing: border-box;
   position: relative;
+  border: 1px solid var(--kb-color-border);
 }
 
-.ProseMirror td:not([data-colwidth]):not(.column-resize-dragging),
-.ProseMirror th:not([data-colwidth]):not(.column-resize-dragging) {
+.kb-editor td:not([data-colwidth]):not(.column-resize-dragging),
+.kb-editor th:not([data-colwidth]):not(.column-resize-dragging) {
   /* if there's no explicit width set and the column is not being resized, set a default width */
   min-width: var(--default-cell-min-width);
 }
 
-.ProseMirror .column-resize-handle {
+.kb-editor .column-resize-handle {
   position: absolute;
   right: -2px;
   top: 0;
@@ -30,12 +31,12 @@
   background-color: #adf;
   pointer-events: none;
 }
-.ProseMirror.resize-cursor {
+.kb-editor.resize-cursor {
   cursor: ew-resize;
   cursor: col-resize;
 }
 /* Give selected cells a blue overlay */
-.ProseMirror .selectedCell:after {
+.kb-editor .selectedCell:after {
   z-index: 2;
   position: absolute;
   content: '';
@@ -46,3 +47,39 @@
   background: rgba(200, 200, 255, 0.4);
   pointer-events: none;
 }
+
+/* Touch-optimized table editing */
+@media (max-width: 767px) {
+  .kb-editor table {
+    font-size: var(--kb-text-sm);
+    border-collapse: collapse;
+    width: 100%;
+    overflow-x: auto;
+    display: block;
+    white-space: nowrap;
+  }
+
+  .kb-editor th,
+  .kb-editor td {
+    min-width: 120px;
+    padding: var(--kb-space-md);
+    border: 1px solid var(--kb-color-border);
+    vertical-align: top;
+  }
+
+  /* Hide complex table controls on mobile */
+  .tableWrapper .column-resize-handle {
+    display: none !important;
+  }
+
+  .kb-editor .tableWrapper {
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+
+  /* Table selection visual feedback */
+  .kb-editor .selectedCell {
+    background: rgba(var(--kb-color-primary-rgb), 0.1);
+    border: 2px solid var(--kb-color-primary);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kerebron/extension-tables",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "license": "MIT",
   "module": "./esm/extension-tables/src/ExtensionTables.js",
   "exports": {
@@ -21,6 +21,9 @@
     }
   },
   "scripts": {},
+  "files": [
+    "assets/*.css"
+  ],
   "dependencies": {
     "prosemirror-keymap": "1.2.2",
     "prosemirror-model": "1.25.1",

package/esm/editor/src/CoreEditor.d.ts

@@ -1,25 +0,0 @@
-import { EditorView } from 'prosemirror-view';
-import { Node as ProseMirrorNode, type Schema } from 'prosemirror-model';
-import type { EditorOptions, JSONContent } from './types.js';
-import { EditorState, Transaction } from 'prosemirror-state';
-import { ChainedCommands } from './commands/CommandManager.js';
-export declare class CoreEditor extends EventTarget {
-    readonly options: Partial<EditorOptions>;
-    private extensionManager;
-    private commandManager;
-    view: EditorView;
-    state: EditorState;
-    constructor(options?: Partial<EditorOptions>);
-    get schema(): Schema<any, any>;
-    chain(): ChainedCommands;
-    can(): ChainedCommands;
-    private createView;
-    dispatchTransaction(transaction: Transaction): void;
-    private setupPlugins;
-    setDocument(content?: any, mediaType?: string): void;
-    getDocument(mediaType?: string): void | ProseMirrorNode | JSONContent;
-    getJSON(): JSONContent;
-    clone(options?: Partial<EditorOptions>): CoreEditor;
-    debug(doc?: ProseMirrorNode): void;
-}
-//# sourceMappingURL=CoreEditor.d.ts.map

package/esm/editor/src/CoreEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CoreEditor.d.ts","sourceRoot":"","sources":["../../../src/editor/src/CoreEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,IAAI,IAAI,eAAe,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGzE,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAkB,MAAM,8BAA8B,CAAC;AAgC/E,qBAAa,UAAW,SAAQ,WAAW;IACzC,SAAgB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAG7C;IACF,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,cAAc,CAAiB;IAChC,IAAI,EAAG,UAAU,CAAC;IAClB,KAAK,EAAG,WAAW,CAAC;gBAEf,OAAO,GAAE,OAAO,CAAC,aAAa,CAAM;IAyBhD,IAAW,MAAM,qBAEhB;IAEM,KAAK,IAAI,eAAe;IAIxB,GAAG,IAAI,eAAe;IAI7B,OAAO,CAAC,UAAU;IAaX,mBAAmB,CAAC,WAAW,EAAE,WAAW;IAcnD,OAAO,CAAC,YAAY;IAcb,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM;IAwC7C,WAAW,CAAC,SAAS,CAAC,EAAE,MAAM;IAkB9B,OAAO,IAAI,WAAW;IAItB,KAAK,CAAC,OAAO,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,UAAU;IAOvD,KAAK,CAAC,GAAG,CAAC,EAAE,eAAe;CAMnC"}

package/esm/editor/src/CoreEditor.js

@@ -1,194 +0,0 @@
-import { EditorView } from 'prosemirror-view';
-import { Node as ProseMirrorNode } from 'prosemirror-model';
-import { ExtensionManager } from './ExtensionManager.js';
-import { EditorState } from 'prosemirror-state';
-import { createNodeFromContent } from './utilities/createNodeFromContent.js';
-import { CommandManager } from './commands/CommandManager.js';
-import { nodeToTreeString } from './nodeToTreeString.js';
-function ensureDocSchema(doc, schema) {
-    if (doc.type.schema != schema) {
-        const findNode = (nodeName) => {
-            if (!schema.nodes[nodeName]) {
-                throw new Error(`Not able to rewrite schema for node '${nodeName}'`);
-            }
-            return schema.nodes[nodeName];
-        };
-        const findMark = (markName) => {
-            if (!schema.marks[markName]) {
-                throw new Error(`Not able to rewrite schema for mark '${markName}'`);
-            }
-            return schema.marks[markName];
-        };
-        // TODO fix readonly warnings
-        doc.type = findNode(doc.type.name);
-        doc.marks.forEach((mark) => {
-            mark.type = findMark(mark.type.name);
-        });
-        doc.descendants((node) => {
-            node.type = findNode(node.type.name);
-            node.marks.forEach((mark) => {
-                mark.type = findMark(mark.type.name);
-            });
-        });
-    }
-}
-export class CoreEditor extends EventTarget {
-    constructor(options = {}) {
-        super();
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                element: null, // document.createElement('div'),
-                extensions: [],
-            }
-        });
-        Object.defineProperty(this, "extensionManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "commandManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "view", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.options = {
-            ...this.options,
-            ...options,
-        };
-        this.extensionManager = new ExtensionManager(this.options.extensions, this);
-        // const content = this.options.content ? this.options.content : {
-        //   type: this.extensionManager.schema.topNodeType.name,
-        //   content: this.extensionManager.schema.topNodeType.spec.EMPTY_DOC,
-        // };
-        const content = this.options.content
-            ? this.options.content
-            : this.extensionManager.schema.topNodeType.spec.EMPTY_DOC;
-        this.createView(content);
-        this.commandManager = new CommandManager(this, this.extensionManager.commandConstructors);
-        this.setupPlugins();
-    }
-    get schema() {
-        return this.extensionManager.schema;
-    }
-    chain() {
-        return this.commandManager.chain();
-    }
-    can() {
-        return this.commandManager.can();
-    }
-    createView(content) {
-        const doc = createNodeFromContent(content, this.schema);
-        this.state = EditorState.create({ doc });
-        if (this.options.element) {
-            this.view = new EditorView(this.options.element, {
-                state: this.state,
-                dispatchTransaction: (tx) => this.dispatchTransaction(tx),
-            });
-        }
-    }
-    dispatchTransaction(transaction) {
-        this.state = this.state.apply(transaction);
-        if (this.view) {
-            this.view.updateState(this.state);
-            const event = new CustomEvent('transaction', {
-                detail: {
-                    editor: this,
-                    transaction,
-                },
-            });
-            this.dispatchEvent(event);
-        }
-    }
-    setupPlugins() {
-        this.state = this.state.reconfigure({
-            plugins: this.extensionManager.plugins,
-        });
-        if (this.view) {
-            this.view.updateState(this.state);
-            this.view.setProps({
-                nodeViews: this.extensionManager.nodeViews,
-            });
-        }
-    }
-    setDocument(content, mediaType) {
-        if (!content) {
-            content = {
-                type: this.extensionManager.schema.topNodeType.name,
-                content: this.extensionManager.schema.topNodeType.spec.EMPTY_DOC.content,
-            };
-            mediaType = undefined;
-        }
-        let doc;
-        if (mediaType) {
-            const converter = this.extensionManager.converters[mediaType];
-            if (converter) {
-                doc = converter.toDoc(content);
-            }
-        }
-        else {
-            doc = createNodeFromContent(content, this.schema);
-        }
-        ensureDocSchema(doc, this.schema);
-        this.state = EditorState.create({
-            doc,
-            plugins: this.state.plugins,
-            storedMarks: this.state.storedMarks,
-        });
-        if (this.view) {
-            this.view.updateState(this.state);
-        }
-        const event = new CustomEvent('doc:loaded', {
-            detail: {
-                editor: this,
-                doc,
-            },
-        });
-        this.dispatchEvent(event);
-    }
-    getDocument(mediaType) {
-        if (mediaType) {
-            const converter = this.extensionManager.converters[mediaType];
-            if (converter) {
-                const json = this.state.doc.toJSON();
-                const clonedDoc = ProseMirrorNode.fromJSON(this.state.schema, json);
-                return converter.fromDoc(clonedDoc);
-            }
-            if (mediaType === 'text/json') {
-                return this.getJSON();
-            }
-        }
-        return this.state.doc;
-    }
-    getJSON() {
-        return this.state.doc.toJSON();
-    }
-    clone(options = {}) {
-        return new CoreEditor({
-            ...options,
-            extensions: [...this.options.extensions],
-        });
-    }
-    debug(doc) {
-        if (!doc) {
-            doc = this.state.doc;
-        }
-        console.debug(nodeToTreeString(doc));
-    }
-}

package/esm/editor/src/Extension.d.ts

@@ -1,26 +0,0 @@
-import { Plugin } from 'prosemirror-state';
-import { type CoreEditor } from './CoreEditor.js';
-import { InputRule } from './plugins/input-rules/InputRulesPlugin.js';
-import { Commands, CommandShortcuts } from './commands/mod.js';
-import { Schema, type SchemaSpec } from 'prosemirror-model';
-export interface ExtensionConfig {
-    [key: string]: any;
-    requires: Array<Extension | string>;
-}
-export interface Converter {
-    fromDoc(document: unknown): void;
-    toDoc(content: unknown): any;
-}
-export declare abstract class Extension {
-    protected config: Partial<ExtensionConfig>;
-    readonly type = "extension";
-    abstract name: string;
-    protected constructor(config?: Partial<ExtensionConfig>);
-    getInputRules(): InputRule[];
-    getProseMirrorPlugins(editor: CoreEditor, schema: Schema): Plugin[];
-    getCommands(editor: CoreEditor): Partial<Commands>;
-    getKeyboardShortcuts(): Partial<CommandShortcuts>;
-    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
-    setupSpec(spec: SchemaSpec): void;
-}
-//# sourceMappingURL=Extension.d.ts.map

package/esm/editor/src/Extension.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Extension.d.ts","sourceRoot":"","sources":["../../../src/editor/src/Extension.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,WAAW,eAAe;IAE9B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAEnB,QAAQ,EAAE,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG,CAAC;CAC9B;AAED,8BAAsB,SAAS;IAIP,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC;IAHhE,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,SAAS,aAAuB,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM;IAGrE,aAAa,IAAI,SAAS,EAAE;IAI5B,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAInE,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIlD,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAIjD,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAI5E,SAAS,CAAC,IAAI,EAAE,UAAU;CAE3B"}

package/esm/editor/src/Extension.js

@@ -1,33 +0,0 @@
-export class Extension {
-    constructor(config = {}) {
-        Object.defineProperty(this, "config", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'extension'
-        });
-    }
-    getInputRules() {
-        return [];
-    }
-    getProseMirrorPlugins(editor, schema) {
-        return [];
-    }
-    getCommands(editor) {
-        return {};
-    }
-    getKeyboardShortcuts() {
-        return {};
-    }
-    getConverters(editor, schema) {
-        return {};
-    }
-    setupSpec(spec) {
-    }
-}

package/esm/editor/src/ExtensionManager.d.ts

@@ -1,32 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
-import { NodeViewConstructor } from 'prosemirror-view';
-import { Extension } from './Extension.js';
-import { AnyExtension } from './types.js';
-import { CoreEditor } from './CoreEditor.js';
-import { Mark } from './Mark.js';
-import { Node } from './Node.js';
-import { type Command } from 'prosemirror-state';
-export declare function findDuplicates(items: any[]): any[];
-export declare function splitExtensions(extensions: Iterable<AnyExtension>): {
-    baseExtensions: Extension[];
-    nodeExtensions: Node[];
-    markExtensions: Mark[];
-};
-export declare class ExtensionManager {
-    private editor;
-    readonly schema: Schema;
-    private extensions;
-    readonly plugins: Plugin[];
-    readonly nodeViews: Record<string, NodeViewConstructor>;
-    readonly commandConstructors: {
-        [key: string]: () => Command;
-    };
-    private converters;
-    private debug;
-    constructor(extensions: Set<AnyExtension>, editor: CoreEditor);
-    private getPlugins;
-    private setupExtensions;
-    getSchemaByResolvedExtensions(editor: CoreEditor): Schema;
-}
-//# sourceMappingURL=ExtensionManager.d.ts.map

package/esm/editor/src/ExtensionManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExtensionManager.d.ts","sourceRoot":"","sources":["../../../src/editor/src/ExtensionManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAa,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAMjC,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAIlD;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC;;;;EAgBjE;AAED,qBAAa,gBAAgB;IAYgB,OAAO,CAAC,MAAM;IAXzD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAgC;IAClD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAM;IAE7D,QAAQ,CAAC,mBAAmB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,OAAO,CAAA;KAAE,CAAM;IACpE,OAAO,CAAC,UAAU,CAAiC;IAEnD,OAAO,CAAC,KAAK,CAAQ;gBAET,UAAU,EAAE,GAAG,CAAC,YAAY,CAAC,EAAU,MAAM,EAAE,UAAU;IAcrE,OAAO,CAAC,UAAU;IAkIlB,OAAO,CAAC,eAAe;IA6DvB,6BAA6B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;CA6C1D"}

package/esm/editor/src/ExtensionManager.js

@@ -1,253 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import { keymap } from 'prosemirror-keymap';
-import { InputRulesPlugin, } from './plugins/input-rules/InputRulesPlugin.js';
-import { chainCommands } from './commands/mod.js';
-import { addAttributesToSchema } from './utilities/getHtmlAttributes.js';
-export function findDuplicates(items) {
-    const filtered = items.filter((el, index) => items.indexOf(el) !== index);
-    return Array.from(new Set(filtered));
-}
-export function splitExtensions(extensions) {
-    const baseExtensions = Array.from(extensions).filter((extension) => extension.type === 'extension');
-    const nodeExtensions = Array.from(extensions).filter((extension) => extension.type === 'node');
-    const markExtensions = Array.from(extensions).filter((extension) => extension.type === 'mark');
-    return {
-        baseExtensions,
-        nodeExtensions,
-        markExtensions,
-    };
-}
-export class ExtensionManager {
-    constructor(extensions, editor) {
-        Object.defineProperty(this, "editor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: editor
-        });
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "extensions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
-        Object.defineProperty(this, "plugins", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "nodeViews", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "commandConstructors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "converters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "debug", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        this.setupExtensions(extensions);
-        this.schema = this.getSchemaByResolvedExtensions(editor);
-        const event = new CustomEvent('schema:ready', {
-            detail: {
-                editor,
-                schema: this.schema,
-            },
-        });
-        editor.dispatchEvent(event);
-        this.plugins = this.getPlugins();
-    }
-    getPlugins() {
-        const plugins = [];
-        const inputRules = [];
-        const commands = new Map();
-        const keyBindings = new Map();
-        const mergeCommands = (toInsert, extName) => {
-            for (const key in toInsert) {
-                const commandConstructor = toInsert[key];
-                if (this.debug) {
-                    const wrappedConstructor = () => {
-                        const realCommand = commandConstructor();
-                        const command = (state, dispatch, view) => {
-                            if (dispatch) {
-                                console.debug(`Command: ${extName}.${key}`);
-                            }
-                            return realCommand(state, dispatch, view);
-                        };
-                        return command;
-                    };
-                    commands.set(key, wrappedConstructor);
-                    this.commandConstructors[key] = wrappedConstructor;
-                }
-                else {
-                    commands.set(key, commandConstructor);
-                    this.commandConstructors[key] = commandConstructor;
-                }
-            }
-        };
-        function mergeShortcuts(toInsert, extName) {
-            for (const key in toInsert) {
-                const commandConstructor = commands.get(toInsert[key]);
-                if (!commandConstructor) {
-                    console.warn(`No command constructor: ${toInsert[key]}`);
-                    continue;
-                }
-                const command = commandConstructor();
-                const keyBinding = keyBindings.get(key);
-                if (keyBinding) {
-                    keyBindings.set(key, chainCommands(keyBinding, command));
-                }
-                else {
-                    keyBindings.set(key, command);
-                }
-            }
-        }
-        let converters = {};
-        for (const extension of this.extensions) {
-            if (extension.type === 'node') {
-                const nodeType = this.schema.nodes[extension.name];
-                inputRules.push(...extension.getInputRules(nodeType));
-                plugins.push(...extension.getProseMirrorPlugins(this.editor, this.schema));
-                mergeCommands(extension.getCommands(this.editor, nodeType), extension.name);
-                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
-                converters = {
-                    ...converters,
-                    ...extension.getConverters(this.editor, this.schema),
-                };
-                const nodeView = extension.getNodeView();
-                if (nodeView) {
-                    this.nodeViews[extension.name] = nodeView;
-                }
-            }
-            if (extension.type === 'mark') {
-                const markType = this.schema.marks[extension.name];
-                inputRules.push(...extension.getInputRules(markType));
-                mergeCommands(extension.getCommands(this.editor, markType), extension.name);
-                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
-            }
-            if (extension.type === 'extension') {
-                plugins.push(...extension.getProseMirrorPlugins(this.editor, this.schema));
-                mergeCommands(extension.getCommands(this.editor), extension.name);
-                mergeShortcuts(extension.getKeyboardShortcuts(this.editor), extension.name);
-                converters = {
-                    ...converters,
-                    ...extension.getConverters(this.editor, this.schema),
-                };
-            }
-        }
-        if (this.debug) {
-            for (const key in keyBindings) {
-                const wrapperCommand = (state, dispatch, view) => {
-                    console.debug(`Key: ${key}`);
-                    return true;
-                };
-                keyBindings.set(key, chainCommands(wrapperCommand, keyBindings.get(key)));
-            }
-        }
-        this.converters = converters;
-        plugins.push(new InputRulesPlugin(inputRules));
-        plugins.push(keymap(Object.fromEntries(keyBindings)));
-        return plugins;
-    }
-    setupExtensions(extensions) {
-        const allExtensions = new Map();
-        const createMap = (extensions) => {
-            for (const extension of extensions) {
-                allExtensions.set(extension.name, extension);
-                if (extension.requires) {
-                    const childExtensions = Array.from(extension.requires).filter((e) => typeof e !== 'string');
-                    createMap(new Set(childExtensions));
-                }
-            }
-        };
-        createMap(extensions);
-        const initialized = new Set();
-        const initializeExtension = (extension) => {
-            console.info(`Initialize ${extension.type} ${extension.name}`);
-            this.extensions.add(extension);
-        };
-        function recursiveInitializeExtension(extension) {
-            if (initialized.has(extension.name)) {
-                return;
-            }
-            const requires = (extension.requires || []).map((e) => typeof e === 'string' ? e : e.name);
-            for (const require of requires) {
-                if (!initialized.has(require)) {
-                    const requiredExtension = allExtensions.get(require);
-                    if (!requiredExtension) {
-                        throw new Error('Required extension not found: ' + require);
-                    }
-                    recursiveInitializeExtension(requiredExtension);
-                }
-            }
-            initializeExtension(extension);
-            initialized.add(extension.name);
-            allExtensions.delete(extension.name);
-        }
-        for (const extension of allExtensions.values()) {
-            recursiveInitializeExtension(extension);
-        }
-        if (allExtensions.size > 0) {
-            throw new Error('Not all extensions initialized: ' +
-                Array.from(allExtensions.keys()).join(', '));
-        }
-    }
-    getSchemaByResolvedExtensions(editor) {
-        const { nodeExtensions, markExtensions, baseExtensions } = splitExtensions(this.extensions);
-        const nodes = {};
-        for (const extension of nodeExtensions) {
-            nodes[extension.name] = extension.getNodeSpec();
-            addAttributesToSchema(nodes[extension.name], extension);
-            if ('automerge' in extension) {
-                nodes[extension.name].automerge = extension.automerge;
-            }
-        }
-        const marks = {};
-        for (const extension of markExtensions) {
-            marks[extension.name] = extension.getMarkSpec();
-            addAttributesToSchema(marks[extension.name], extension);
-            if ('automerge' in extension) {
-                marks[extension.name].automerge = extension.automerge;
-            }
-        }
-        const spec = {
-            topNode: this.editor.options.topNode || 'doc',
-            nodes,
-            marks,
-        };
-        for (const extension of baseExtensions) {
-            if ('setupSpec' in baseExtensions) {
-                baseExtensions.setupSpec(spec);
-            }
-        }
-        const event = new CustomEvent('schema:spec', {
-            detail: {
-                editor,
-                spec,
-            },
-        });
-        editor.dispatchEvent(event);
-        return new Schema(spec);
-    }
-}