@kerebron/editor 0.0.1

package/LICENSE

@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# Kerebron core editor
+
+Core editor is basic agnostic. All you need is an HTML element.
+
+## Usage
+
+```js
+import { CoreEditor } from '@kerebron/editor';
+import { ExtensionBasicEditor } from '@kerebron/extension-basic-editor';
+import { ExtensionHistory } from '@kerebron/extension-basic-editor/ExtensionHistory';
+import { ExtensionMenu } from '@kerebron/extension-menu';
+
+this.editor = new CoreEditor({
+  element: document.querySelector('div#editor'),
+  extensions: [
+    new ExtensionBasicEditor(),
+    new ExtensionHistory(),
+    new ExtensionMenu(),
+  ],
+});
+```

package/esm/CoreEditor.d.ts

@@ -0,0 +1,29 @@
+import { EditorView } from 'prosemirror-view';
+import { Fragment, type Schema } from 'prosemirror-model';
+import type { EditorOptions, JSONContent } from './types.js';
+import { EditorState } from 'prosemirror-state';
+import { ChainedCommands } from './commands/CommandManager.js';
+export declare function getHTMLFromFragment(fragment: Fragment, schema: Schema): string;
+export declare class CoreEditor extends EventTarget {
+    readonly options: Partial<EditorOptions>;
+    private extensionManager;
+    private commandManager;
+    view: EditorView;
+    constructor(options?: Partial<EditorOptions>);
+    private createExtensionManager;
+    get schema(): Schema;
+    get state(): EditorState;
+    chain(): ChainedCommands;
+    can(): ChainedCommands;
+    private createView;
+    private dispatchTransaction;
+    private setupPlugins;
+    getJSON(): JSONContent;
+    /**
+     * Get the document as HTML.
+     */
+    getHTML(): string;
+    setDocument(content?: any, mediaType?: string): void;
+    getDocument(mediaType?: string): any;
+}
+//# sourceMappingURL=CoreEditor.d.ts.map

package/esm/CoreEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreEditor.d.ts","sourceRoot":"","sources":["../src/CoreEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAEL,QAAQ,EAGR,KAAK,MAAM,EACZ,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAW,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,WAAW,EAAe,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAkB,MAAM,8BAA8B,CAAC;AAE/E,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAWR;AAeD,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;gBAEb,OAAO,GAAE,OAAO,CAAC,aAAa,CAAM;IA0BhD,OAAO,CAAC,sBAAsB;IAI9B,IAAW,MAAM,WAEhB;IAED,IAAW,KAAK,IAAI,WAAW,CAE9B;IAEM,KAAK,IAAI,eAAe;IAIxB,GAAG,IAAI,eAAe;IAI7B,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,YAAY;IAYb,OAAO,IAAI,WAAW;IAI7B;;OAEG;IACI,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM;IA0C7C,WAAW,CAAC,SAAS,CAAC,EAAE,MAAM;CAUtC"}

package/esm/CoreEditor.js

@@ -0,0 +1,162 @@
+import { EditorView } from 'prosemirror-view';
+import { DOMSerializer, } 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';
+export function getHTMLFromFragment(fragment, schema) {
+    const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+    const temporaryDocument = document.implementation.createHTMLDocument();
+    const container = temporaryDocument.createElement('div');
+    container.appendChild(documentFragment);
+    return container.innerHTML;
+}
+function createDocument(content, schema, parseOptions = {}, options = {}) {
+    return createNodeFromContent(content, schema, {
+        slice: false,
+        parseOptions,
+        errorOnInvalidContent: options.errorOnInvalidContent,
+    });
+}
+export class CoreEditor extends EventTarget {
+    constructor(options = {}) {
+        super();
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                element: 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
+        });
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        this.extensionManager = this.createExtensionManager();
+        // 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(structuredClone(content));
+        // this.createView('');
+        this.commandManager = new CommandManager(this, this.extensionManager.commandConstructors);
+        this.setupPlugins();
+    }
+    createExtensionManager() {
+        return new ExtensionManager(this.options.extensions, this);
+    }
+    get schema() {
+        return this.extensionManager.schema;
+    }
+    get state() {
+        return this.view.state;
+    }
+    chain() {
+        return this.commandManager.chain();
+    }
+    can() {
+        return this.commandManager.can();
+    }
+    createView(content) {
+        let doc = createDocument(content, this.schema, this.options.parseOptions, { errorOnInvalidContent: false });
+        const state = EditorState.create({ doc });
+        this.view = new EditorView(this.options.element, {
+            state,
+            dispatchTransaction: (tx) => this.dispatchTransaction(tx),
+        });
+    }
+    dispatchTransaction(transaction) {
+        const nextState = this.state.apply(transaction);
+        this.view.updateState(nextState);
+        const event = new CustomEvent('transaction', {
+            detail: {
+                editor: this,
+                transaction,
+            },
+        });
+        this.dispatchEvent(event);
+    }
+    setupPlugins() {
+        const newState = this.state.reconfigure({
+            plugins: this.extensionManager.plugins,
+        });
+        this.view.updateState(newState);
+        this.view.setProps({
+            nodeViews: this.extensionManager.nodeViews,
+        });
+    }
+    getJSON() {
+        return this.state.doc.toJSON();
+    }
+    /**
+     * Get the document as HTML.
+     */
+    getHTML() {
+        return getHTMLFromFragment(this.state.doc.content, this.schema);
+    }
+    setDocument(content, mediaType) {
+        if (!content) { // clear
+            content = {
+                type: this.extensionManager.schema.topNodeType.name,
+                content: this.extensionManager.schema.topNodeType.spec.EMPTY_DOC.content,
+                // content: this.extensionManager.schema.topNodeType.createAndFill(),
+            };
+            mediaType = undefined;
+        }
+        let doc;
+        if (mediaType) {
+            const converter = this.extensionManager.converters[mediaType];
+            if (converter) {
+                doc = converter.toDoc(content);
+            }
+        }
+        else {
+            doc = createDocument(content, this.schema, this.options.parseOptions, { errorOnInvalidContent: false });
+        }
+        const newState = EditorState.create({
+            doc,
+            plugins: this.view.state.plugins,
+            storedMarks: this.view.state.storedMarks,
+        });
+        this.view.updateState(newState);
+        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) {
+                return converter.fromDoc(this.state.doc);
+            }
+        }
+        return this.state.doc;
+    }
+}

package/esm/Extension.d.ts

@@ -0,0 +1,26 @@
+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(): Record<string, Converter>;
+    setupSpec(spec: SchemaSpec): void;
+}
+//# sourceMappingURL=Extension.d.ts.map

package/esm/Extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extension.d.ts","sourceRoot":"","sources":["../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,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAI1C,SAAS,CAAC,IAAI,EAAE,UAAU;CAE3B"}

package/esm/Extension.js

@@ -0,0 +1,33 @@
+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() {
+        return {};
+    }
+    setupSpec(spec) {
+    }
+}

package/esm/ExtensionManager.d.ts

@@ -0,0 +1,32 @@
+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/ExtensionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.d.ts","sourceRoot":"","sources":["../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/ExtensionManager.js

@@ -0,0 +1,253 @@
+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);
+    }
+}

package/esm/Mark.d.ts

@@ -0,0 +1,18 @@
+import { MarkSpec, MarkType } from 'prosemirror-model';
+import { InputRule } from './plugins/input-rules/InputRulesPlugin.js';
+import { CoreEditor } from './CoreEditor.js';
+import { Commands, CommandShortcuts } from './commands/mod.js';
+export interface MarkConfig {
+    [key: string]: any;
+}
+export declare abstract class Mark {
+    protected config: Partial<MarkConfig>;
+    readonly type = "mark";
+    name: string;
+    constructor(config?: Partial<MarkConfig>);
+    getMarkSpec(): MarkSpec;
+    getInputRules(type: MarkType): InputRule[];
+    getCommands(editor: CoreEditor, type: MarkType): Partial<Commands>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=Mark.d.ts.map

package/esm/Mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mark.d.ts","sourceRoot":"","sources":["../src/Mark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE/D,MAAM,WAAW,UAAU;IAEzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,8BAAsB,IAAI;IAIL,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IAHxD,QAAQ,CAAC,IAAI,UAAU;IACvB,IAAI,EAAE,MAAM,CAAU;gBAEO,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAE7D,WAAW,IAAI,QAAQ;IAIvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAI1C,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAGlD"}

package/esm/Mark.js

@@ -0,0 +1,34 @@
+export class Mark {
+    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: 'mark'
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'node'
+        });
+    }
+    getMarkSpec() {
+        throw new Error('MarkSpec not defined: ' + this.name);
+    }
+    getInputRules(type) {
+        return [];
+    }
+    getCommands(editor, type) {
+        return {};
+    }
+    getKeyboardShortcuts() {
+        return {};
+    }
+}