@qalma/editor 0.0.1-alpha.0

package/fesm2022/qalma-editor.mjs

@@ -0,0 +1,3228 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, input, inject, computed, Directive, DestroyRef, viewChild, afterNextRender, ChangeDetectionStrategy, Component, forwardRef, signal } from '@angular/core';
+import { EditorView, DecorationSet, Decoration } from 'prosemirror-view';
+import { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';
+import { keymap } from 'prosemirror-keymap';
+import { baseKeymap, lift, wrapIn, setBlockType, toggleMark } from 'prosemirror-commands';
+import { EditorState, Plugin, NodeSelection, TextSelection } from 'prosemirror-state';
+import { redo, undo, history } from 'prosemirror-history';
+import { bulletList, orderedList, listItem, liftListItem, sinkListItem, splitListItemKeepMarks, wrapInList } from 'prosemirror-schema-list';
+
+const QALMA_EDITOR_CONTEXT = new InjectionToken('QALMA_EDITOR_CONTEXT');
+
+class QalmaCommand {
+    command = input.required({ ...(ngDevMode ? { debugName: "command" } : /* istanbul ignore next */ {}), alias: 'qalmaCommand' });
+    qalmaCommandValue = input(...(ngDevMode ? [undefined, { debugName: "qalmaCommandValue" }] : /* istanbul ignore next */ []));
+    context = inject(QALMA_EDITOR_CONTEXT);
+    editor = computed(() => this.context.editor(), ...(ngDevMode ? [{ debugName: "editor" }] : /* istanbul ignore next */ []));
+    active = computed(() => this.editor().isCommandActive(this.command()), ...(ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []));
+    disabled = computed(() => !this.editor().canExecute(this.command(), this.qalmaCommandValue()), ...(ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []));
+    ariaPressed = computed(() => this.editor().hasCommandState(this.command())
+        ? String(this.active())
+        : null, ...(ngDevMode ? [{ debugName: "ariaPressed" }] : /* istanbul ignore next */ []));
+    execute() {
+        this.editor().execute(this.command(), this.qalmaCommandValue());
+    }
+    preserveSelection(event) {
+        event.preventDefault();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaCommand, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.16", type: QalmaCommand, isStandalone: true, selector: "button[qalmaCommand]", inputs: { command: { classPropertyName: "command", publicName: "qalmaCommand", isSignal: true, isRequired: true, transformFunction: null }, qalmaCommandValue: { classPropertyName: "qalmaCommandValue", publicName: "qalmaCommandValue", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "execute()", "mousedown": "preserveSelection($event)" }, properties: { "attr.aria-pressed": "ariaPressed()", "class.qalma-command-active": "active()", "disabled": "disabled()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaCommand, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[qalmaCommand]',
+                    host: {
+                        '(click)': 'execute()',
+                        '(mousedown)': 'preserveSelection($event)',
+                        '[attr.aria-pressed]': 'ariaPressed()',
+                        '[class.qalma-command-active]': 'active()',
+                        '[disabled]': 'disabled()',
+                    },
+                }]
+        }], propDecorators: { command: [{ type: i0.Input, args: [{ isSignal: true, alias: "qalmaCommand", required: true }] }], qalmaCommandValue: [{ type: i0.Input, args: [{ isSignal: true, alias: "qalmaCommandValue", required: false }] }] } });
+
+class QalmaContent {
+    context = inject(QALMA_EDITOR_CONTEXT);
+    destroyRef = inject(DestroyRef);
+    editorHost = viewChild.required('editorHost');
+    mountedHost;
+    constructor() {
+        afterNextRender(() => {
+            const host = this.editorHost().nativeElement;
+            this.context.editor().mount(host);
+            this.mountedHost = host;
+        });
+        this.destroyRef.onDestroy(() => {
+            if (this.mountedHost) {
+                this.context.editor().unmount(this.mountedHost);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaContent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "21.2.16", type: QalmaContent, isStandalone: true, selector: "qalma-content", host: { properties: { "class.qalma-content": "true" } }, viewQueries: [{ propertyName: "editorHost", first: true, predicate: ["editorHost"], descendants: true, isSignal: true }], ngImport: i0, template: `<div #editorHost class="qalma-content-surface"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaContent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'qalma-content',
+                    imports: [],
+                    template: `<div #editorHost class="qalma-content-surface"></div>`,
+                    host: {
+                        '[class.qalma-content]': 'true',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { editorHost: [{ type: i0.ViewChild, args: ['editorHost', { isSignal: true }] }] } });
+
+class QalmaEditor {
+    editor = input.required(...(ngDevMode ? [{ debugName: "editor" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaEditor, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.16", type: QalmaEditor, isStandalone: true, selector: "qalma-editor", inputs: { editor: { classPropertyName: "editor", publicName: "editor", isSignal: true, isRequired: true, transformFunction: null } }, host: { properties: { "class.qalma-editor": "true" } }, providers: [
+            {
+                provide: QALMA_EDITOR_CONTEXT,
+                useExisting: forwardRef(() => QalmaEditor),
+            },
+        ], ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaEditor, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'qalma-editor',
+                    imports: [],
+                    providers: [
+                        {
+                            provide: QALMA_EDITOR_CONTEXT,
+                            useExisting: forwardRef(() => QalmaEditor),
+                        },
+                    ],
+                    template: `<ng-content />`,
+                    host: {
+                        '[class.qalma-editor]': 'true',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { editor: [{ type: i0.Input, args: [{ isSignal: true, alias: "editor", required: true }] }] } });
+
+function parseHtmlDocument(html, schema) {
+    const container = document.createElement('div');
+    container.innerHTML = html.trim() || '<p></p>';
+    return DOMParser.fromSchema(schema).parse(container);
+}
+function serializeHtmlDocument(doc, schema) {
+    const fragment = DOMSerializer.fromSchema(schema).serializeFragment(doc.content);
+    const container = document.createElement('div');
+    container.appendChild(fragment);
+    return container.innerHTML.replace(/\n/g, '&#10;');
+}
+
+function createBasePlugins(schema, qalmaPlugins) {
+    const shortcuts = createShortcutRegistry(schema, qalmaPlugins);
+    return [
+        ...qalmaPlugins.flatMap((plugin) => plugin.prosemirrorPlugins?.(schema) ?? []),
+        ...(Object.keys(shortcuts).length > 0 ? [keymap(shortcuts)] : []),
+        keymap(baseKeymap),
+    ];
+}
+function createCommandRegistry(schema, qalmaPlugins) {
+    const commands = {};
+    for (const plugin of qalmaPlugins) {
+        for (const [name, command] of Object.entries(plugin.commands?.(schema) ?? {})) {
+            if (commands[name]) {
+                throw new Error(`QALMA plugin "${plugin.key}" defines duplicate command "${name}".`);
+            }
+            commands[name] = command;
+        }
+    }
+    return commands;
+}
+function createCommandStateRegistry(schema, qalmaPlugins) {
+    const states = {};
+    for (const plugin of qalmaPlugins) {
+        for (const [commandName, query] of Object.entries(plugin.commandStates?.(schema) ?? {})) {
+            if (states[commandName]) {
+                throw new Error(`QALMA plugin "${plugin.key}" defines duplicate command state "${commandName}".`);
+            }
+            states[commandName] = query;
+        }
+    }
+    return states;
+}
+function createQueryRegistry(schema, qalmaPlugins) {
+    const queries = {};
+    for (const plugin of qalmaPlugins) {
+        for (const [name, query] of Object.entries(plugin.queries?.(schema) ?? {})) {
+            if (queries[name]) {
+                throw new Error(`QALMA plugin "${plugin.key}" defines duplicate query "${name}".`);
+            }
+            queries[name] = query;
+        }
+    }
+    return queries;
+}
+function createShortcutRegistry(schema, qalmaPlugins) {
+    const shortcuts = {};
+    for (const plugin of qalmaPlugins) {
+        for (const [shortcut, command] of Object.entries(plugin.shortcuts?.(schema) ?? {})) {
+            if (shortcuts[shortcut]) {
+                throw new Error(`QALMA plugin "${plugin.key}" defines duplicate shortcut "${shortcut}".`);
+            }
+            shortcuts[shortcut] = command;
+        }
+    }
+    return shortcuts;
+}
+
+const baseNodes = {
+    doc: {
+        content: 'block+',
+    },
+    paragraph: {
+        content: 'inline*',
+        group: 'block',
+        parseDOM: [{ tag: 'p' }],
+        toDOM: () => ['p', 0],
+    },
+    text: {
+        group: 'inline',
+    },
+};
+function createQalmaSchema(plugins) {
+    assertUniquePluginKeys(plugins);
+    const nodes = { ...baseNodes };
+    const marks = {};
+    for (const plugin of plugins) {
+        addUniqueEntries(nodes, plugin.nodes, plugin.key, 'node');
+        addUniqueEntries(marks, plugin.marks, plugin.key, 'mark');
+    }
+    for (const plugin of plugins) {
+        extendExistingNodes(nodes, plugin.extendNodes?.(Object.freeze({ ...nodes })), plugin.key);
+    }
+    return new Schema({
+        nodes,
+        marks,
+    });
+}
+function assertUniquePluginKeys(plugins) {
+    const keys = new Set();
+    for (const plugin of plugins) {
+        if (keys.has(plugin.key)) {
+            throw new Error(`Duplicate QALMA plugin key "${plugin.key}".`);
+        }
+        keys.add(plugin.key);
+    }
+}
+function addUniqueEntries(target, entries, pluginKey, type) {
+    for (const [name, spec] of Object.entries(entries ?? {})) {
+        if (target[name]) {
+            throw new Error(`QALMA plugin "${pluginKey}" defines duplicate ${type} "${name}".`);
+        }
+        target[name] = spec;
+    }
+}
+function extendExistingNodes(nodes, extensions, pluginKey) {
+    for (const [name, spec] of Object.entries(extensions ?? {})) {
+        if (!nodes[name]) {
+            throw new Error(`QALMA plugin "${pluginKey}" extends unknown node "${name}".`);
+        }
+        nodes[name] = spec;
+    }
+}
+
+function createQalmaState(options) {
+    return EditorState.create({
+        doc: parseHtmlDocument(options.html, options.schema),
+        schema: options.schema,
+        plugins: createBasePlugins(options.schema, options.plugins),
+    });
+}
+
+class QalmaEditorController {
+    html;
+    editable;
+    plugins;
+    schema;
+    htmlState;
+    editableState;
+    viewVersion = signal(0, ...(ngDevMode ? [{ debugName: "viewVersion" }] : /* istanbul ignore next */ []));
+    commands;
+    commandStates;
+    queries;
+    editorState;
+    editorView;
+    host;
+    constructor(options = {}) {
+        this.plugins = [...(options.plugins ?? [])];
+        this.schema = createQalmaSchema(this.plugins);
+        this.commands = createCommandRegistry(this.schema, this.plugins);
+        this.commandStates = createCommandStateRegistry(this.schema, this.plugins);
+        this.queries = createQueryRegistry(this.schema, this.plugins);
+        this.htmlState = signal(options.content ?? '<p></p>', ...(ngDevMode ? [{ debugName: "htmlState" }] : /* istanbul ignore next */ []));
+        this.editableState = signal(options.editable ?? true, ...(ngDevMode ? [{ debugName: "editableState" }] : /* istanbul ignore next */ []));
+        this.html = this.htmlState.asReadonly();
+        this.editable = this.editableState.asReadonly();
+    }
+    mount(host) {
+        if (this.host === host && this.editorView) {
+            return;
+        }
+        this.unmount();
+        host.replaceChildren();
+        this.editorState = createQalmaState({
+            html: this.html(),
+            plugins: this.plugins,
+            schema: this.schema,
+        });
+        this.host = host;
+        this.editorView = new EditorView(host, {
+            state: this.editorState,
+            editable: () => this.editable(),
+            attributes: this.createEditorAttributes(),
+            dispatchTransaction: (transaction) => this.dispatchTransaction(transaction),
+        });
+        this.syncHtmlFromEditorState();
+        this.bumpViewVersion();
+    }
+    unmount(host) {
+        if (host && host !== this.host) {
+            return;
+        }
+        this.editorView?.destroy();
+        this.editorView = undefined;
+        this.editorState = undefined;
+        this.host = undefined;
+        this.bumpViewVersion();
+    }
+    execute(commandName, value) {
+        const command = this.commands[commandName];
+        if (!this.editable() || !command || !this.editorState) {
+            return false;
+        }
+        const executed = command(this.editorState, (transaction) => this.dispatchTransaction(transaction), this.editorView, value);
+        if (executed) {
+            this.editorView?.focus();
+        }
+        return executed;
+    }
+    canExecute(commandName, value) {
+        this.viewVersion();
+        const command = this.commands[commandName];
+        return Boolean(this.editable() &&
+            command &&
+            this.editorState &&
+            command(this.editorState, undefined, this.editorView, value));
+    }
+    hasCommandState(commandName) {
+        return Boolean(this.commandStates[commandName]);
+    }
+    isCommandActive(commandName) {
+        this.viewVersion();
+        const query = this.commandStates[commandName];
+        return Boolean(query && this.editorState && query(this.editorState));
+    }
+    hasQuery(queryName) {
+        return Boolean(this.queries[queryName]);
+    }
+    query(queryName) {
+        this.viewVersion();
+        const query = this.queries[queryName];
+        return query && this.editorState
+            ? query(this.editorState)
+            : null;
+    }
+    setHtml(html) {
+        if (html === this.html()) {
+            return;
+        }
+        if (!this.editorView) {
+            this.htmlState.set(html);
+            return;
+        }
+        this.editorState = createQalmaState({
+            html,
+            plugins: this.plugins,
+            schema: this.schema,
+        });
+        this.editorView.updateState(this.editorState);
+        this.syncHtmlFromEditorState();
+        this.bumpViewVersion();
+    }
+    setEditable(editable) {
+        this.editableState.set(editable);
+        this.editorView?.setProps({
+            editable: () => editable,
+        });
+    }
+    focus() {
+        this.editorView?.focus();
+    }
+    dispatchTransaction(transaction) {
+        if (!this.editorState) {
+            return;
+        }
+        this.editorState = this.editorState.apply(transaction);
+        this.editorView?.updateState(this.editorState);
+        if (transaction.docChanged) {
+            this.syncHtmlFromEditorState();
+        }
+        this.bumpViewVersion();
+    }
+    syncHtmlFromEditorState() {
+        if (!this.editorState) {
+            return;
+        }
+        const html = serializeHtmlDocument(this.editorState.doc, this.schema);
+        if (html !== this.html()) {
+            this.htmlState.set(html);
+        }
+    }
+    bumpViewVersion() {
+        this.viewVersion.update((value) => value + 1);
+    }
+    createEditorAttributes() {
+        return {
+            'aria-label': 'Rich text editor',
+        };
+    }
+}
+function createQalmaEditor(options = {}) {
+    return new QalmaEditorController(options);
+}
+
+class QalmaToolbar {
+    label = input('Editor toolbar', ...(ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaToolbar, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.16", type: QalmaToolbar, isStandalone: true, selector: "qalma-toolbar", inputs: { label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "role": "toolbar" }, properties: { "class.qalma-toolbar": "true", "attr.aria-label": "label()" } }, ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.16", ngImport: i0, type: QalmaToolbar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'qalma-toolbar',
+                    imports: [],
+                    template: `<ng-content />`,
+                    host: {
+                        '[class.qalma-toolbar]': 'true',
+                        role: 'toolbar',
+                        '[attr.aria-label]': 'label()',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { label: [{ type: i0.Input, args: [{ isSignal: true, alias: "label", required: false }] }] } });
+
+function createQalmaPlugin(plugin) {
+    return plugin;
+}
+function createConfigurableQalmaPlugin(defaultOptions, createPlugin, options = {}) {
+    const resolvedOptions = Object.freeze({
+        ...defaultOptions,
+        ...options,
+    });
+    const plugin = createPlugin(resolvedOptions);
+    return Object.assign(plugin, {
+        options: resolvedOptions,
+        configure(nextOptions = {}) {
+            return createConfigurableQalmaPlugin(defaultOptions, createPlugin, {
+                ...resolvedOptions,
+                ...nextOptions,
+            });
+        },
+    });
+}
+
+const blockquoteNode = {
+    content: 'block+',
+    group: 'block',
+    defining: true,
+    parseDOM: [{ tag: 'blockquote' }],
+    toDOM: () => ['blockquote', 0],
+};
+const BlockquotePlugin = createQalmaPlugin({
+    key: 'blockquote',
+    nodes: {
+        blockquote: blockquoteNode,
+    },
+    commands: (schema) => ({
+        toggleBlockquote: createToggleBlockquoteCommand(schema.nodes['blockquote']),
+    }),
+    commandStates: (schema) => ({
+        toggleBlockquote: (state) => isBlockquoteActive(state, schema.nodes['blockquote']),
+    }),
+});
+const BlockquoteKit = [BlockquotePlugin];
+function createToggleBlockquoteCommand(blockquote) {
+    return (state, dispatch) => {
+        if (isBlockquoteActive(state, blockquote)) {
+            return lift(state, dispatch);
+        }
+        return wrapIn(blockquote)(state, dispatch);
+    };
+}
+function isBlockquoteActive(state, blockquote) {
+    const { $from } = state.selection;
+    for (let depth = $from.depth; depth > 0; depth -= 1) {
+        if ($from.node(depth).type === blockquote) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const ClearFormattingPlugin = createQalmaPlugin({
+    key: 'clearFormatting',
+    commands: (schema) => ({
+        clearFormatting: createClearFormattingCommand(schema.nodes['paragraph']),
+    }),
+});
+const ClearFormattingKit = [
+    ClearFormattingPlugin,
+];
+function createClearFormattingCommand(paragraph) {
+    return (state, dispatch) => {
+        const markRanges = getMarkRangesToClear(state);
+        const hasMarksToClear = Boolean(state.storedMarks?.length) ||
+            markRanges.some((range) => rangeHasInlineMarks(state.doc, range.from, range.to));
+        const hasTextblocksToClear = selectionHasTextblockFormattingToClear(state, paragraph);
+        if (!hasMarksToClear && !hasTextblocksToClear) {
+            return false;
+        }
+        if (dispatch) {
+            const transaction = state.tr;
+            if (state.storedMarks?.length) {
+                transaction.setStoredMarks([]);
+            }
+            if (hasMarksToClear) {
+                for (const range of markRanges) {
+                    if (range.from < range.to) {
+                        transaction.removeMark(range.from, range.to, null);
+                    }
+                }
+            }
+            if (hasTextblocksToClear) {
+                for (const range of state.selection.ranges) {
+                    transaction.setBlockType(range.$from.pos, range.$to.pos, paragraph);
+                }
+            }
+            dispatch(transaction.scrollIntoView());
+        }
+        return true;
+    };
+}
+function getMarkRangesToClear(state) {
+    if (!state.selection.empty) {
+        return state.selection.ranges.map((range) => ({
+            from: range.$from.pos,
+            to: range.$to.pos,
+        }));
+    }
+    const { $from } = state.selection;
+    if ($from.depth === 0 || !$from.parent.inlineContent) {
+        return [];
+    }
+    return [
+        {
+            from: $from.start(),
+            to: $from.end(),
+        },
+    ];
+}
+function rangeHasInlineMarks(doc, from, to) {
+    if (from >= to) {
+        return false;
+    }
+    let hasMarks = false;
+    doc.nodesBetween(from, to, (node) => {
+        if (hasMarks) {
+            return false;
+        }
+        if (node.isInline && node.marks.length > 0) {
+            hasMarks = true;
+            return false;
+        }
+        return undefined;
+    });
+    return hasMarks;
+}
+function selectionHasTextblockFormattingToClear(state, paragraph) {
+    let applicable = false;
+    for (const range of state.selection.ranges) {
+        if (applicable) {
+            break;
+        }
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+            if (applicable) {
+                return false;
+            }
+            if (!node.isTextblock || node.hasMarkup(paragraph)) {
+                return undefined;
+            }
+            if (node.type === paragraph) {
+                applicable = true;
+                return false;
+            }
+            const $pos = state.doc.resolve(pos);
+            const index = $pos.index();
+            if ($pos.parent.canReplaceWith(index, index + 1, paragraph)) {
+                applicable = true;
+                return false;
+            }
+            return undefined;
+        });
+    }
+    return applicable;
+}
+
+const CODE_BLOCK_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    languages: Object.freeze(['plaintext']),
+    defaultLanguage: 'plaintext',
+    languageClassPrefix: 'language-',
+    indentText: '  ',
+});
+const CodeBlockPlugin = createConfigurableQalmaPlugin(CODE_BLOCK_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertCodeBlockPluginOptions(options);
+    const codeBlockNode = {
+        attrs: {
+            language: { default: options.defaultLanguage },
+        },
+        content: 'text*',
+        marks: '',
+        group: 'block',
+        code: true,
+        defining: true,
+        parseDOM: [
+            {
+                tag: 'pre',
+                preserveWhitespace: 'full',
+                getAttrs: (node) => ({
+                    language: resolveParsedLanguage(node, options),
+                }),
+            },
+        ],
+        toDOM: (node) => [
+            'pre',
+            [
+                'code',
+                {
+                    class: `${options.languageClassPrefix}${resolveNodeLanguage(node.attrs['language'], options)}`,
+                },
+                0,
+            ],
+        ],
+    };
+    return createQalmaPlugin({
+        key: 'codeBlock',
+        nodes: {
+            codeBlock: codeBlockNode,
+        },
+        commands: (schema) => ({
+            toggleCodeBlock: createToggleCodeBlockCommand(schema.nodes['codeBlock'], schema.nodes['paragraph'], options),
+            setCodeBlockLanguage: createSetCodeBlockLanguageCommand(schema.nodes['codeBlock'], options),
+        }),
+        commandStates: (schema) => ({
+            toggleCodeBlock: (state) => isCodeBlockActive(state, schema.nodes['codeBlock']),
+        }),
+        queries: (schema) => ({
+            codeBlockLanguage: (state) => getActiveCodeBlock(state, schema.nodes['codeBlock'])?.node.attrs['language'] ?? null,
+        }),
+        shortcuts: (schema) => ({
+            'Mod-Alt-c': createToggleCodeBlockCommand(schema.nodes['codeBlock'], schema.nodes['paragraph'], options),
+        }),
+        prosemirrorPlugins: (schema) => [
+            createCodeBlockKeyboardPlugin(schema.nodes['codeBlock'], options),
+        ],
+    });
+});
+const CodeBlockKit = [CodeBlockPlugin];
+function createToggleCodeBlockCommand(codeBlock, paragraph, options) {
+    return (state, dispatch, _view, value) => {
+        if (isCodeBlockActive(state, codeBlock)) {
+            return setBlockType(paragraph)(state, dispatch);
+        }
+        const language = value === undefined
+            ? options.defaultLanguage
+            : resolveCommandLanguage(value, options);
+        if (!language) {
+            return false;
+        }
+        return setBlockType(codeBlock, { language })(state, dispatch);
+    };
+}
+function createSetCodeBlockLanguageCommand(codeBlock, options) {
+    return (state, dispatch, _view, value) => {
+        const language = resolveCommandLanguage(value, options);
+        const activeCodeBlock = getActiveCodeBlock(state, codeBlock);
+        if (!language || !activeCodeBlock) {
+            return false;
+        }
+        if (activeCodeBlock.node.attrs['language'] === language) {
+            return true;
+        }
+        if (dispatch) {
+            dispatch(state.tr
+                .setNodeMarkup(activeCodeBlock.position, codeBlock, {
+                ...activeCodeBlock.node.attrs,
+                language,
+            })
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+function isCodeBlockActive(state, codeBlock) {
+    return Boolean(getActiveCodeBlock(state, codeBlock));
+}
+function createCodeBlockKeyboardPlugin(codeBlock, options) {
+    return new Plugin({
+        props: {
+            handleKeyDown: (view, event) => {
+                if (event.key !== 'Tab') {
+                    return false;
+                }
+                const activeCodeBlock = getActiveCodeBlock(view.state, codeBlock);
+                if (!activeCodeBlock) {
+                    return false;
+                }
+                event.preventDefault();
+                const transaction = event.shiftKey
+                    ? outdentCodeBlockSelection(view.state, activeCodeBlock, options)
+                    : indentCodeBlockSelection(view.state, activeCodeBlock, options);
+                if (transaction) {
+                    view.dispatch(transaction.scrollIntoView());
+                }
+                return true;
+            },
+        },
+    });
+}
+function indentCodeBlockSelection(state, activeCodeBlock, options) {
+    const contentStart = activeCodeBlock.position + 1;
+    const lineStarts = getSelectedLineStarts(state, activeCodeBlock);
+    const transaction = state.tr;
+    for (const lineStart of [...lineStarts].reverse()) {
+        transaction.insertText(options.indentText, contentStart + lineStart);
+    }
+    return transaction;
+}
+function outdentCodeBlockSelection(state, activeCodeBlock, options) {
+    const contentStart = activeCodeBlock.position + 1;
+    const lineStarts = getSelectedLineStarts(state, activeCodeBlock);
+    const text = activeCodeBlock.node.textContent;
+    const transaction = state.tr;
+    let changed = false;
+    for (const lineStart of [...lineStarts].reverse()) {
+        const deleteLength = getOutdentLength(text.slice(lineStart), options);
+        if (deleteLength === 0) {
+            continue;
+        }
+        transaction.delete(contentStart + lineStart, contentStart + lineStart + deleteLength);
+        changed = true;
+    }
+    return changed ? transaction : null;
+}
+function getSelectedLineStarts(state, activeCodeBlock) {
+    const contentStart = activeCodeBlock.position + 1;
+    const text = activeCodeBlock.node.textContent;
+    const selectionFrom = Math.max(0, state.selection.from - contentStart);
+    const selectionTo = Math.max(0, state.selection.to - contentStart);
+    const firstLineStart = getLineStart(text, selectionFrom);
+    const lastSelectedOffset = state.selection.empty || selectionTo === 0
+        ? selectionFrom
+        : selectionTo - 1;
+    const lastLineStart = getLineStart(text, lastSelectedOffset);
+    const lineStarts = [firstLineStart];
+    let nextLineBreak = text.indexOf('\n', firstLineStart);
+    while (nextLineBreak !== -1 && nextLineBreak + 1 <= lastLineStart) {
+        lineStarts.push(nextLineBreak + 1);
+        nextLineBreak = text.indexOf('\n', nextLineBreak + 1);
+    }
+    return lineStarts;
+}
+function getLineStart(text, offset) {
+    return text.lastIndexOf('\n', offset - 1) + 1;
+}
+function getOutdentLength(line, options) {
+    if (line.startsWith(options.indentText)) {
+        return options.indentText.length;
+    }
+    if (line.startsWith('\t')) {
+        return 1;
+    }
+    const leadingSpaces = line.match(/^ +/)?.[0].length ?? 0;
+    return Math.min(leadingSpaces, options.indentText.length);
+}
+function getActiveCodeBlock(state, codeBlock) {
+    const { $from, $to } = state.selection;
+    if ($from.parent.type !== codeBlock ||
+        $to.parent.type !== codeBlock ||
+        $from.depth === 0) {
+        return null;
+    }
+    return {
+        node: $from.parent,
+        position: $from.before($from.depth),
+    };
+}
+function resolveParsedLanguage(node, options) {
+    if (!(node instanceof HTMLElement)) {
+        return options.defaultLanguage;
+    }
+    const code = node.matches('code') ? node : node.querySelector('code');
+    const language = resolveLanguageFromElement(code, options) ??
+        resolveLanguageFromElement(node, options);
+    return language ?? options.defaultLanguage;
+}
+function resolveLanguageFromElement(element, options) {
+    if (!element) {
+        return null;
+    }
+    const classNames = Array.from(element.classList);
+    const prefixes = Array.from(new Set([options.languageClassPrefix, 'language-', 'lang-']));
+    for (const className of classNames) {
+        for (const prefix of prefixes) {
+            if (className.startsWith(prefix)) {
+                return resolveLanguageId(className.slice(prefix.length), options);
+            }
+        }
+    }
+    return null;
+}
+function resolveNodeLanguage(language, options) {
+    return resolveLanguageId(language, options) ?? options.defaultLanguage;
+}
+function resolveCommandLanguage(value, options) {
+    return resolveLanguageId(value, options);
+}
+function resolveLanguageId(value, options) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const language = value.trim().toLowerCase();
+    return options.languages.includes(language) ? language : null;
+}
+function assertCodeBlockPluginOptions(options) {
+    if (!Array.isArray(options.languages)) {
+        throw new TypeError('CodeBlockPlugin languages must be an array.');
+    }
+    if (options.languages.length === 0) {
+        throw new RangeError('CodeBlockPlugin languages must include at least one language.');
+    }
+    const seen = new Set();
+    for (const language of options.languages) {
+        assertLanguageId(language, 'CodeBlockPlugin languages entries');
+        if (seen.has(language)) {
+            throw new Error('CodeBlockPlugin languages entries must be unique.');
+        }
+        seen.add(language);
+    }
+    assertLanguageId(options.defaultLanguage, 'CodeBlockPlugin defaultLanguage');
+    if (!seen.has(options.defaultLanguage)) {
+        throw new Error('CodeBlockPlugin defaultLanguage must be included in languages.');
+    }
+    if (typeof options.languageClassPrefix !== 'string' ||
+        options.languageClassPrefix.trim() !== options.languageClassPrefix ||
+        options.languageClassPrefix.length === 0 ||
+        /\s/.test(options.languageClassPrefix)) {
+        throw new Error('CodeBlockPlugin languageClassPrefix must be a non-empty string without whitespace.');
+    }
+    if (typeof options.indentText !== 'string' ||
+        options.indentText.length === 0 ||
+        !/^[\t ]+$/.test(options.indentText)) {
+        throw new Error('CodeBlockPlugin indentText must be a non-empty string containing only spaces or tabs.');
+    }
+}
+function assertLanguageId(value, label) {
+    if (typeof value !== 'string' ||
+        value.trim() !== value ||
+        value.toLowerCase() !== value ||
+        !/^[a-z][a-z0-9-]*$/.test(value)) {
+        throw new Error(`${label} must be lowercase language identifiers without whitespace.`);
+    }
+}
+
+const ColorPlugin = createQalmaPlugin({
+    key: 'color',
+    marks: {
+        textStyle: createTextStyleMark(),
+    },
+    commands: (schema) => ({
+        setTextColor: createSetTextStyleCommand(schema.marks['textStyle'], 'color'),
+        unsetTextColor: createUnsetTextStyleCommand(schema.marks['textStyle'], 'color'),
+        setBackgroundColor: createSetTextStyleCommand(schema.marks['textStyle'], 'backgroundColor'),
+        unsetBackgroundColor: createUnsetTextStyleCommand(schema.marks['textStyle'], 'backgroundColor'),
+    }),
+    commandStates: (schema) => ({
+        unsetTextColor: (state) => isTextStyleAttributeActive(state, schema.marks['textStyle'], 'color'),
+        unsetBackgroundColor: (state) => isTextStyleAttributeActive(state, schema.marks['textStyle'], 'backgroundColor'),
+    }),
+    queries: (schema) => ({
+        textColor: (state) => getActiveTextStyleAttrs(state, schema.marks['textStyle'])?.color ?? null,
+        backgroundColor: (state) => getActiveTextStyleAttrs(state, schema.marks['textStyle'])
+            ?.backgroundColor ?? null,
+    }),
+});
+const ColorKit = [ColorPlugin];
+function createTextStyleMark() {
+    return {
+        attrs: {
+            color: { default: null },
+            backgroundColor: { default: null },
+        },
+        parseDOM: [
+            {
+                tag: '[style]',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    return getTextStyleAttrsFromElement(node) ?? false;
+                },
+            },
+            {
+                tag: 'font[color]',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    const color = normalizeCssColor$1(node.getAttribute('color'), 'color');
+                    return color ? { color, backgroundColor: null } : false;
+                },
+            },
+        ],
+        toDOM: (mark) => [
+            'span',
+            {
+                style: createTextStyleAttribute(getTextStyleAttrs(mark)),
+            },
+            0,
+        ],
+    };
+}
+function createSetTextStyleCommand(mark, attribute) {
+    return (state, dispatch, _view, value) => {
+        const color = normalizeCommandColor$1(value, getCssPropertyName(attribute));
+        if (!color || !markApplies$1(state, mark)) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(updateTextStyleMarks(state, mark, (attrs) => ({
+                ...attrs,
+                [attribute]: color,
+            })).scrollIntoView());
+        }
+        return true;
+    };
+}
+function createUnsetTextStyleCommand(mark, attribute) {
+    return (state, dispatch) => {
+        if (!isTextStyleAttributeActive(state, mark, attribute)) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(updateTextStyleMarks(state, mark, (attrs) => ({
+                ...attrs,
+                [attribute]: null,
+            })).scrollIntoView());
+        }
+        return true;
+    };
+}
+function updateTextStyleMarks(state, mark, updateAttrs) {
+    if (state.selection.empty) {
+        return updateStoredTextStyleMark(state, mark, updateAttrs);
+    }
+    const transaction = state.tr;
+    for (const range of state.selection.ranges) {
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, position) => {
+            if (!node.isText || position >= range.$to.pos) {
+                return undefined;
+            }
+            const from = Math.max(position, range.$from.pos);
+            const to = Math.min(position + node.nodeSize, range.$to.pos);
+            const currentMark = mark.isInSet(node.marks);
+            const nextAttrs = updateAttrs(getTextStyleAttrs(currentMark));
+            transaction.removeMark(from, to, mark);
+            if (hasTextStyleAttrs(nextAttrs)) {
+                transaction.addMark(from, to, mark.create(nextAttrs));
+            }
+            return undefined;
+        });
+    }
+    return transaction;
+}
+function updateStoredTextStyleMark(state, mark, updateAttrs) {
+    const marks = state.storedMarks ?? state.selection.$from.marks();
+    const nextAttrs = updateAttrs(getTextStyleAttrs(mark.isInSet(marks)));
+    const transaction = state.tr.removeStoredMark(mark);
+    if (hasTextStyleAttrs(nextAttrs)) {
+        transaction.addStoredMark(mark.create(nextAttrs));
+    }
+    return transaction;
+}
+function isTextStyleAttributeActive(state, mark, attribute) {
+    const attrs = getActiveTextStyleAttrs(state, mark);
+    return Boolean(attrs?.[attribute]);
+}
+function getActiveTextStyleAttrs(state, mark) {
+    if (state.selection.empty) {
+        const activeMark = mark.isInSet(state.storedMarks ?? state.selection.$from.marks());
+        return activeMark ? getTextStyleAttrs(activeMark) : null;
+    }
+    let activeMark = null;
+    state.doc.nodesBetween(state.selection.from, state.selection.to, (node) => {
+        if (activeMark) {
+            return false;
+        }
+        if (node.isText) {
+            activeMark = mark.isInSet(node.marks) ?? null;
+        }
+        return undefined;
+    });
+    return activeMark ? getTextStyleAttrs(activeMark) : null;
+}
+function getTextStyleAttrs(mark) {
+    return {
+        color: normalizeCssColor$1(mark?.attrs['color'], 'color'),
+        backgroundColor: normalizeCssColor$1(mark?.attrs['backgroundColor'], 'background-color'),
+    };
+}
+function getTextStyleAttrsFromElement(element) {
+    const attrs = {
+        color: normalizeCssColor$1(element.style.color, 'color'),
+        backgroundColor: normalizeCssColor$1(element.style.backgroundColor, 'background-color'),
+    };
+    return hasTextStyleAttrs(attrs) ? attrs : null;
+}
+function createTextStyleAttribute(attrs) {
+    return [
+        attrs.color ? `color: ${attrs.color};` : '',
+        attrs.backgroundColor ? `background-color: ${attrs.backgroundColor};` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
+function hasTextStyleAttrs(attrs) {
+    return Boolean(attrs.color || attrs.backgroundColor);
+}
+function normalizeCommandColor$1(value, cssPropertyName) {
+    return typeof value === 'string'
+        ? normalizeCssColor$1(value, cssPropertyName)
+        : null;
+}
+function normalizeCssColor$1(value, cssPropertyName) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const color = value.trim();
+    if (!color || /[;{}<>]/.test(color)) {
+        return null;
+    }
+    if (typeof document === 'undefined') {
+        return color;
+    }
+    const element = document.createElement('span');
+    element.style.setProperty(cssPropertyName, color);
+    return element.style.getPropertyValue(cssPropertyName) || null;
+}
+function getCssPropertyName(attribute) {
+    return attribute === 'color' ? 'color' : 'background-color';
+}
+function markApplies$1(state, mark) {
+    if (state.selection.empty) {
+        const { $from } = state.selection;
+        return $from.parent.inlineContent && $from.parent.type.allowsMarkType(mark);
+    }
+    for (const range of state.selection.ranges) {
+        let applies = false;
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node) => {
+            if (applies) {
+                return false;
+            }
+            applies = node.inlineContent && node.type.allowsMarkType(mark);
+            return undefined;
+        });
+        if (applies) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const hardBreakNode = {
+    inline: true,
+    group: 'inline',
+    selectable: false,
+    linebreakReplacement: true,
+    parseDOM: [{ tag: 'br' }],
+    toDOM: () => ['br'],
+    leafText: () => '\n',
+};
+const HardBreakPlugin = createQalmaPlugin({
+    key: 'hardBreak',
+    nodes: {
+        hardBreak: hardBreakNode,
+    },
+    commands: (schema) => ({
+        insertHardBreak: createInsertHardBreakCommand(schema.nodes['hardBreak']),
+    }),
+    shortcuts: (schema) => ({
+        'Shift-Enter': createInsertHardBreakCommand(schema.nodes['hardBreak']),
+    }),
+});
+const HardBreakKit = [HardBreakPlugin];
+function createInsertHardBreakCommand(hardBreak) {
+    return (state, dispatch) => {
+        if (!canInsertHardBreak(state, hardBreak)) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(state.tr.replaceSelectionWith(hardBreak.create()).scrollIntoView());
+        }
+        return true;
+    };
+}
+function canInsertHardBreak(state, hardBreak) {
+    const { $from, $to } = state.selection;
+    return ($from.sameParent($to) &&
+        $from.parent.inlineContent &&
+        $from.parent.canReplaceWith($from.index(), $to.index(), hardBreak));
+}
+
+const HIGHLIGHT_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    defaultColor: 'rgb(254, 240, 138)',
+});
+const HighlightPlugin = createConfigurableQalmaPlugin(HIGHLIGHT_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    const defaultColor = normalizeCssColor(options.defaultColor, 'background-color');
+    assertDefaultHighlightColor(defaultColor);
+    return createQalmaPlugin({
+        key: 'highlight',
+        marks: {
+            highlight: createHighlightMark(defaultColor),
+        },
+        commands: (schema) => ({
+            setHighlight: createSetHighlightCommand(schema.marks['highlight'], defaultColor),
+            unsetHighlight: createUnsetHighlightCommand(schema.marks['highlight']),
+        }),
+        commandStates: (schema) => ({
+            setHighlight: (state) => isHighlightActive(state, schema.marks['highlight']),
+        }),
+        queries: (schema) => ({
+            highlightColor: (state) => getActiveHighlightColor(state, schema.marks['highlight']),
+        }),
+    });
+});
+const HighlightKit = [HighlightPlugin];
+function createHighlightMark(defaultColor) {
+    return {
+        attrs: {
+            color: { default: defaultColor },
+        },
+        parseDOM: [
+            {
+                tag: 'mark',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    return {
+                        color: normalizeCssColor(node.style.backgroundColor, 'background-color') ?? defaultColor,
+                    };
+                },
+            },
+        ],
+        toDOM: (mark) => {
+            const color = getHighlightColor(mark, defaultColor);
+            return color === defaultColor
+                ? ['mark', 0]
+                : ['mark', { style: `background-color: ${color};` }, 0];
+        },
+    };
+}
+function createSetHighlightCommand(mark, defaultColor) {
+    return (state, dispatch, _view, value) => {
+        const color = value === undefined
+            ? defaultColor
+            : normalizeCommandColor(value, 'background-color');
+        if (!color || !markApplies(state, mark)) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(updateHighlightMarks(state, mark, () => color).scrollIntoView());
+        }
+        return true;
+    };
+}
+function createUnsetHighlightCommand(mark) {
+    return (state, dispatch) => {
+        if (!isHighlightActive(state, mark)) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(updateHighlightMarks(state, mark, () => null).scrollIntoView());
+        }
+        return true;
+    };
+}
+function updateHighlightMarks(state, mark, getNextColor) {
+    if (state.selection.empty) {
+        return updateStoredHighlightMark(state, mark, getNextColor);
+    }
+    const transaction = state.tr;
+    for (const range of state.selection.ranges) {
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, position) => {
+            if (!node.isText || position >= range.$to.pos) {
+                return undefined;
+            }
+            const from = Math.max(position, range.$from.pos);
+            const to = Math.min(position + node.nodeSize, range.$to.pos);
+            const color = getNextColor();
+            transaction.removeMark(from, to, mark);
+            if (color) {
+                transaction.addMark(from, to, mark.create({ color }));
+            }
+            return undefined;
+        });
+    }
+    return transaction;
+}
+function updateStoredHighlightMark(state, mark, getNextColor) {
+    const color = getNextColor();
+    const transaction = state.tr.removeStoredMark(mark);
+    if (color) {
+        transaction.addStoredMark(mark.create({ color }));
+    }
+    return transaction;
+}
+function isHighlightActive(state, mark) {
+    return Boolean(getActiveHighlightMark(state, mark));
+}
+function getActiveHighlightColor(state, mark) {
+    return getActiveHighlightMark(state, mark)?.attrs['color'] ?? null;
+}
+function getActiveHighlightMark(state, mark) {
+    if (state.selection.empty) {
+        return (mark.isInSet(state.storedMarks ?? state.selection.$from.marks()) ?? null);
+    }
+    let activeMark = null;
+    state.doc.nodesBetween(state.selection.from, state.selection.to, (node) => {
+        if (activeMark) {
+            return false;
+        }
+        if (node.isText) {
+            activeMark = mark.isInSet(node.marks) ?? null;
+        }
+        return undefined;
+    });
+    return activeMark;
+}
+function getHighlightColor(mark, defaultColor) {
+    return (normalizeCssColor(mark.attrs['color'], 'background-color') ?? defaultColor);
+}
+function normalizeCommandColor(value, cssPropertyName) {
+    return typeof value === 'string'
+        ? normalizeCssColor(value, cssPropertyName)
+        : null;
+}
+function normalizeCssColor(value, cssPropertyName) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const color = value.trim();
+    if (!color || /[;{}<>]/.test(color)) {
+        return null;
+    }
+    if (typeof document === 'undefined') {
+        return color;
+    }
+    const element = document.createElement('span');
+    element.style.setProperty(cssPropertyName, color);
+    return element.style.getPropertyValue(cssPropertyName) || null;
+}
+function markApplies(state, mark) {
+    if (state.selection.empty) {
+        const { $from } = state.selection;
+        return $from.parent.inlineContent && $from.parent.type.allowsMarkType(mark);
+    }
+    for (const range of state.selection.ranges) {
+        let applies = false;
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node) => {
+            if (applies) {
+                return false;
+            }
+            applies = node.inlineContent && node.type.allowsMarkType(mark);
+            return undefined;
+        });
+        if (applies) {
+            return true;
+        }
+    }
+    return false;
+}
+function assertDefaultHighlightColor(defaultColor) {
+    if (!defaultColor) {
+        throw new Error('HighlightPlugin defaultColor must be a valid CSS color.');
+    }
+}
+
+const HISTORY_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    depth: 100,
+    newGroupDelay: 500,
+});
+const HistoryPlugin = createConfigurableQalmaPlugin(HISTORY_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertHistoryPluginOptions(options);
+    return createQalmaPlugin({
+        key: 'history',
+        prosemirrorPlugins: () => [history(options)],
+        commands: () => ({
+            undo,
+            redo,
+        }),
+        shortcuts: () => ({
+            'Mod-z': undo,
+            'Shift-Mod-z': redo,
+            'Mod-y': redo,
+        }),
+    });
+});
+function assertHistoryPluginOptions(options) {
+    if (!Number.isInteger(options.depth) || options.depth < 1) {
+        throw new RangeError('HistoryPlugin depth must be a positive integer.');
+    }
+    if (!Number.isFinite(options.newGroupDelay) || options.newGroupDelay < 0) {
+        throw new RangeError('HistoryPlugin newGroupDelay must be a non-negative finite number.');
+    }
+}
+
+const HEADING_LEVELS = Object.freeze([
+    1, 2, 3, 4, 5, 6,
+]);
+const HEADINGS_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    levels: Object.freeze([1, 2, 3]),
+});
+const HeadingsPlugin = createConfigurableQalmaPlugin(HEADINGS_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertHeadingsPluginOptions(options);
+    const headingNode = {
+        attrs: {
+            level: { default: options.levels[0] },
+        },
+        content: 'inline*',
+        defining: true,
+        group: 'block',
+        parseDOM: options.levels.map((level) => ({
+            tag: `h${level}`,
+            attrs: { level },
+        })),
+        toDOM: (node) => [`h${node.attrs['level']}`, 0],
+    };
+    return createQalmaPlugin({
+        key: 'headings',
+        nodes: {
+            heading: headingNode,
+        },
+        commands: (schema) => ({
+            setParagraph: createSetParagraphCommand(schema.nodes['paragraph']),
+            ...createHeadingCommands(schema.nodes['heading'], schema.nodes['paragraph'], options.levels),
+        }),
+        commandStates: (schema) => ({
+            setParagraph: (state) => isParagraphActive(state),
+            ...createHeadingCommandStates(schema.nodes['heading'], options.levels),
+        }),
+        shortcuts: (schema) => createHeadingShortcuts(schema, options.levels),
+    });
+});
+const HeadingsKit = [HeadingsPlugin];
+function createSetParagraphCommand(paragraph) {
+    return (state, dispatch) => {
+        if (isParagraphActive(state)) {
+            return true;
+        }
+        return setBlockType(paragraph)(state, dispatch);
+    };
+}
+function createHeadingCommands(heading, paragraph, levels) {
+    return Object.fromEntries(levels.map((level) => [
+        getHeadingCommandName(level),
+        createToggleHeadingCommand(heading, paragraph, level),
+    ]));
+}
+function createToggleHeadingCommand(heading, paragraph, level) {
+    return (state, dispatch) => {
+        if (isHeadingActive(state, heading, level)) {
+            return setBlockType(paragraph)(state, dispatch);
+        }
+        return setBlockType(heading, { level })(state, dispatch);
+    };
+}
+function createHeadingCommandStates(heading, levels) {
+    return Object.fromEntries(levels.map((level) => [
+        getHeadingCommandName(level),
+        (state) => isHeadingActive(state, heading, level),
+    ]));
+}
+function createHeadingShortcuts(schema, levels) {
+    return Object.fromEntries(levels.map((level) => [
+        `Mod-Alt-${level}`,
+        createToggleHeadingCommand(schema.nodes['heading'], schema.nodes['paragraph'], level),
+    ]));
+}
+function getHeadingCommandName(level) {
+    return `toggleHeading${level}`;
+}
+function isParagraphActive(state) {
+    return state.selection.$from.parent.type === state.schema.nodes['paragraph'];
+}
+function isHeadingActive(state, heading, level) {
+    const parent = state.selection.$from.parent;
+    return parent.type === heading && parent.attrs['level'] === level;
+}
+function assertHeadingsPluginOptions(options) {
+    if (!Array.isArray(options.levels)) {
+        throw new TypeError('HeadingsPlugin levels must be an array.');
+    }
+    if (options.levels.length === 0) {
+        throw new RangeError('HeadingsPlugin levels must include at least one heading level.');
+    }
+    const seen = new Set();
+    for (const level of options.levels) {
+        if (!HEADING_LEVELS.includes(level)) {
+            throw new RangeError('HeadingsPlugin levels entries must be integers from 1 through 6.');
+        }
+        if (seen.has(level)) {
+            throw new Error('HeadingsPlugin levels entries must be unique.');
+        }
+        seen.add(level);
+    }
+}
+
+const IMAGE_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    allowedProtocols: Object.freeze(['http', 'https']),
+    allowRelativeImages: true,
+    defaultAlt: '',
+});
+const ImagePlugin = createConfigurableQalmaPlugin(IMAGE_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertImagePluginOptions(options);
+    const imageNode = {
+        attrs: {
+            src: {},
+            alt: { default: options.defaultAlt },
+            title: { default: null },
+            previewSrc: { default: null },
+        },
+        atom: true,
+        draggable: true,
+        inline: true,
+        group: 'inline',
+        parseDOM: [
+            {
+                tag: 'img[src]',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    const src = normalizeImageSrc(node.getAttribute('src'), options);
+                    if (!src) {
+                        return false;
+                    }
+                    return {
+                        src,
+                        alt: normalizeAlt(node.getAttribute('alt') ?? options.defaultAlt),
+                        title: normalizeTitle(node.getAttribute('title')),
+                        previewSrc: null,
+                    };
+                },
+            },
+        ],
+        selectable: true,
+        toDOM: (node) => {
+            const attrs = {
+                src: node.attrs['src'],
+                alt: normalizeAlt(node.attrs['alt']),
+            };
+            const title = normalizeTitle(node.attrs['title']);
+            if (title) {
+                attrs['title'] = title;
+            }
+            return ['img', attrs];
+        },
+    };
+    return createQalmaPlugin({
+        key: 'image',
+        nodes: {
+            image: imageNode,
+        },
+        commands: (schema) => ({
+            insertImage: createInsertImageCommand(schema.nodes['image'], options),
+            updateImage: createUpdateImageCommand(schema.nodes['image'], options),
+            removeImage: createRemoveImageCommand(schema.nodes['image']),
+        }),
+        commandStates: (schema) => ({
+            insertImage: (state) => Boolean(getSelectedImage(state, schema.nodes['image'])),
+        }),
+        queries: (schema) => ({
+            image: (state) => getImageState(state, schema.nodes['image']),
+        }),
+        prosemirrorPlugins: () => [createImagePreviewPlugin()],
+    });
+});
+const ImageKit = [ImagePlugin];
+function createInsertImageCommand(image, options) {
+    return (state, dispatch, _view, value) => {
+        const attrs = resolveImageAttrs(value, options);
+        if (!attrs || !canReplaceSelectionWithImage(state, image)) {
+            return false;
+        }
+        if (dispatch) {
+            const imageNode = image.create(attrs);
+            const transaction = state.tr.replaceSelectionWith(imageNode, false);
+            const insertedPosition = transaction.selection.from - imageNode.nodeSize;
+            if (transaction.doc.nodeAt(insertedPosition)?.type === image) {
+                transaction.setSelection(NodeSelection.create(transaction.doc, insertedPosition));
+            }
+            dispatch(transaction.scrollIntoView());
+        }
+        return true;
+    };
+}
+function createUpdateImageCommand(image, options) {
+    return (state, dispatch, _view, value) => {
+        const selectedImage = getSelectedImage(state, image);
+        const attrs = resolveImageAttrs({
+            ...selectedImage?.node.attrs,
+            ...resolveImageUpdateValue(value),
+        }, options);
+        if (!selectedImage || !attrs) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(state.tr
+                .setNodeMarkup(selectedImage.from, image, attrs)
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+function createRemoveImageCommand(image) {
+    return (state, dispatch) => {
+        const selectedImage = getSelectedImage(state, image);
+        if (!selectedImage) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(state.tr.delete(selectedImage.from, selectedImage.to).scrollIntoView());
+        }
+        return true;
+    };
+}
+function getSelectedImage(state, image) {
+    const { selection } = state;
+    if (!(selection instanceof NodeSelection) || selection.node.type !== image) {
+        return null;
+    }
+    return {
+        node: selection.node,
+        from: selection.from,
+        to: selection.to,
+    };
+}
+function getImageState(state, image) {
+    const selectedImage = getSelectedImage(state, image);
+    return selectedImage
+        ? {
+            from: selectedImage.from,
+            to: selectedImage.to,
+            src: selectedImage.node.attrs['src'],
+            alt: normalizeAlt(selectedImage.node.attrs['alt']),
+            title: normalizeTitle(selectedImage.node.attrs['title']),
+            previewSrc: normalizePreviewSrc(selectedImage.node.attrs['previewSrc']),
+        }
+        : null;
+}
+function canReplaceSelectionWithImage(state, image) {
+    const { $from } = state.selection;
+    for (let depth = $from.depth; depth >= 0; depth--) {
+        const index = $from.index(depth);
+        if ($from.node(depth).canReplaceWith(index, index, image)) {
+            return true;
+        }
+    }
+    return false;
+}
+function resolveImageAttrs(value, options) {
+    const rawValue = typeof value === 'string'
+        ? { src: value }
+        : isImageCommandValue(value)
+            ? value
+            : null;
+    if (!rawValue) {
+        return null;
+    }
+    const src = normalizeImageSrc(rawValue.src, options);
+    if (!src) {
+        return null;
+    }
+    return {
+        src,
+        alt: normalizeAlt(rawValue.alt ?? options.defaultAlt),
+        title: normalizeTitle(rawValue.title),
+        previewSrc: normalizePreviewSrc(rawValue.previewSrc),
+    };
+}
+function normalizeImageSrc(value, options) {
+    const src = value?.trim();
+    if (!src) {
+        return null;
+    }
+    const protocol = src.match(/^([a-z][a-z0-9+.-]*):/i)?.[1].toLowerCase();
+    if (!protocol) {
+        return options.allowRelativeImages && !src.startsWith('//') ? src : null;
+    }
+    return options.allowedProtocols.includes(protocol) ? src : null;
+}
+function normalizeAlt(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeTitle(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    return value.trim() || null;
+}
+function normalizePreviewSrc(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const src = value.trim();
+    if (!src) {
+        return null;
+    }
+    return src.startsWith('blob:') || /^data:image\//i.test(src) ? src : null;
+}
+function isImageCommandValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'src' in value &&
+        typeof value.src === 'string');
+}
+function createImagePreviewPlugin() {
+    return new Plugin({
+        props: {
+            nodeViews: {
+                image: (node) => {
+                    return new ImageNodeView(node);
+                },
+            },
+        },
+    });
+}
+class ImageNodeView {
+    node;
+    dom = document.createElement('img');
+    constructor(node) {
+        this.node = node;
+        this.render();
+    }
+    update(node) {
+        if (node.type !== this.node.type) {
+            return false;
+        }
+        this.node = node;
+        this.render();
+        return true;
+    }
+    render() {
+        const src = normalizePreviewSrc(this.node.attrs['previewSrc']) ??
+            this.node.attrs['src'];
+        const title = normalizeTitle(this.node.attrs['title']);
+        this.dom.src = src;
+        this.dom.alt = normalizeAlt(this.node.attrs['alt']);
+        if (title) {
+            this.dom.title = title;
+        }
+        else {
+            this.dom.removeAttribute('title');
+        }
+    }
+}
+function resolveImageUpdateValue(value) {
+    if (typeof value === 'string') {
+        return { src: value };
+    }
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function assertImagePluginOptions(options) {
+    if (!Array.isArray(options.allowedProtocols)) {
+        throw new TypeError('ImagePlugin allowedProtocols must be an array.');
+    }
+    if (options.allowedProtocols.length === 0) {
+        throw new RangeError('ImagePlugin allowedProtocols must include at least one protocol.');
+    }
+    const seen = new Set();
+    for (const protocol of options.allowedProtocols) {
+        if (typeof protocol !== 'string' || !/^[a-z][a-z0-9+.-]*$/.test(protocol)) {
+            throw new TypeError('ImagePlugin allowedProtocols entries must be protocol names without colons.');
+        }
+        if (seen.has(protocol)) {
+            throw new Error('ImagePlugin allowedProtocols entries must be unique.');
+        }
+        seen.add(protocol);
+    }
+    if (typeof options.allowRelativeImages !== 'boolean') {
+        throw new TypeError('ImagePlugin allowRelativeImages must be a boolean.');
+    }
+    if (typeof options.defaultAlt !== 'string') {
+        throw new TypeError('ImagePlugin defaultAlt must be a string.');
+    }
+}
+
+function isMarkActive(state, mark) {
+    const { from, $from, to, empty } = state.selection;
+    if (empty) {
+        return Boolean(mark.isInSet(state.storedMarks ?? $from.marks()));
+    }
+    return state.doc.rangeHasMark(from, to, mark);
+}
+
+const LINK_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    allowedProtocols: Object.freeze(['http', 'https', 'mailto', 'tel']),
+    allowRelativeLinks: true,
+    defaultTarget: '_blank',
+    defaultRel: 'noopener noreferrer',
+});
+const LinkPlugin = createConfigurableQalmaPlugin(LINK_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertLinkPluginOptions(options);
+    const linkMark = {
+        attrs: {
+            href: {},
+            target: { default: null },
+            rel: { default: null },
+        },
+        inclusive: false,
+        parseDOM: [
+            {
+                tag: 'a[href]',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    const href = normalizeHref$1(node.getAttribute('href'), options);
+                    if (!href) {
+                        return false;
+                    }
+                    return {
+                        href,
+                        target: normalizeTarget(node.getAttribute('target') ?? options.defaultTarget),
+                        rel: normalizeRel(node.getAttribute('rel') ?? options.defaultRel),
+                    };
+                },
+            },
+        ],
+        toDOM: (mark) => {
+            const attrs = {
+                href: mark.attrs['href'],
+            };
+            const target = normalizeTarget(mark.attrs['target']);
+            const rel = normalizeRel(mark.attrs['rel']);
+            if (target) {
+                attrs['target'] = target;
+            }
+            if (rel) {
+                attrs['rel'] = rel;
+            }
+            return ['a', attrs, 0];
+        },
+    };
+    return createQalmaPlugin({
+        key: 'link',
+        marks: {
+            link: linkMark,
+        },
+        commands: (schema) => ({
+            setLink: createSetLinkCommand(schema.marks['link'], options),
+            selectLink: createSelectLinkCommand(schema.marks['link']),
+            unsetLink: createUnsetLinkCommand(schema.marks['link']),
+        }),
+        commandStates: (schema) => ({
+            setLink: (state) => isMarkActive(state, schema.marks['link']),
+        }),
+        queries: (schema) => ({
+            link: (state) => getLinkState(state, schema.marks['link']),
+        }),
+        prosemirrorPlugins: () => [createOpenLinkPlugin(options)],
+    });
+});
+function createSetLinkCommand(mark, options) {
+    return (state, dispatch, _view, value) => {
+        const attrs = resolveLinkAttrs(value, options);
+        if (!attrs || !selectionAllowsMark(state, mark)) {
+            return false;
+        }
+        if (dispatch) {
+            const transaction = state.tr;
+            if (state.selection.empty) {
+                transaction.addStoredMark(mark.create(attrs));
+            }
+            else {
+                for (const range of state.selection.ranges) {
+                    transaction.removeMark(range.$from.pos, range.$to.pos, mark);
+                    transaction.addMark(range.$from.pos, range.$to.pos, mark.create(attrs));
+                }
+            }
+            dispatch(transaction.scrollIntoView());
+        }
+        return true;
+    };
+}
+function createUnsetLinkCommand(mark) {
+    return (state, dispatch) => {
+        if (!isMarkActive(state, mark)) {
+            return false;
+        }
+        if (dispatch) {
+            const transaction = state.tr.removeStoredMark(mark);
+            for (const range of state.selection.ranges) {
+                transaction.removeMark(range.$from.pos, range.$to.pos, mark);
+            }
+            dispatch(transaction.scrollIntoView());
+        }
+        return true;
+    };
+}
+function createSelectLinkCommand(mark) {
+    return (state, dispatch, view, value) => {
+        const range = resolveLinkSelectionRange(state, mark, view, value);
+        if (!range) {
+            return false;
+        }
+        if (dispatch) {
+            dispatch(state.tr
+                .setSelection(TextSelection.create(state.doc, range.from, range.to))
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+function createOpenLinkPlugin(options) {
+    return new Plugin({
+        props: {
+            handleDOMEvents: {
+                click: (_view, event) => {
+                    const link = findClickedLink(event.target);
+                    if (!link) {
+                        return false;
+                    }
+                    const href = normalizeHref$1(link.getAttribute('href'), options);
+                    if (!href) {
+                        return false;
+                    }
+                    event.preventDefault();
+                    const linkTarget = normalizeTarget(link.getAttribute('target')) ??
+                        options.defaultTarget;
+                    if (linkTarget === '_blank') {
+                        window.open(href, '_blank', 'noopener,noreferrer');
+                    }
+                    else {
+                        window.location.href = href;
+                    }
+                    return true;
+                },
+            },
+        },
+    });
+}
+function findClickedLink(target) {
+    if (!(target instanceof Node)) {
+        return null;
+    }
+    const element = target instanceof Element ? target : target.parentElement;
+    if (!element) {
+        return null;
+    }
+    const link = element.closest('a[href]');
+    return link instanceof HTMLAnchorElement ? link : null;
+}
+function resolveLinkSelectionRange(state, mark, view, value) {
+    if (isLinkRangeTarget(value)) {
+        return hasLinkBetween(state, mark, value.from, value.to) ? value : null;
+    }
+    if (isLinkElementTarget(value) && view) {
+        const position = getElementDocumentPosition(view, value.element);
+        if (position === null) {
+            return null;
+        }
+        const range = findLinkRange(state.doc.resolve(position), mark);
+        return range ? { from: range.from, to: range.to } : null;
+    }
+    const stateValue = getLinkState(state, mark);
+    return stateValue
+        ? {
+            from: stateValue.from,
+            to: stateValue.to,
+        }
+        : null;
+}
+function getElementDocumentPosition(view, element) {
+    try {
+        return view.posAtDOM(element.firstChild ?? element, 0);
+    }
+    catch {
+        return null;
+    }
+}
+function getLinkState(state, mark) {
+    if (state.selection.empty) {
+        const range = findLinkRange(state.selection.$from, mark);
+        return range ? createLinkState(state, range) : null;
+    }
+    let found = null;
+    state.doc.nodesBetween(state.selection.from, state.selection.to, (_node, pos) => {
+        if (found) {
+            return false;
+        }
+        const range = findLinkRange(state.doc.resolve(pos), mark);
+        if (range) {
+            found = range;
+            return false;
+        }
+        return undefined;
+    });
+    return found ? createLinkState(state, found) : null;
+}
+function findLinkRange($position, mark) {
+    const parent = $position.parent;
+    const after = parent.childAfter($position.parentOffset);
+    const before = parent.childBefore($position.parentOffset);
+    const current = mark.isInSet(after.node?.marks ?? []);
+    const previous = mark.isInSet(before.node?.marks ?? []);
+    const link = current ?? previous;
+    if (!link) {
+        return null;
+    }
+    let startIndex = current ? after.index : before.index;
+    let endIndex = startIndex + 1;
+    let from = $position.start() + (current ? after.offset : before.offset);
+    let to = from + (current ? after.node?.nodeSize ?? 0 : before.node?.nodeSize ?? 0);
+    while (startIndex > 0 &&
+        hasSameMark(parent.child(startIndex - 1).marks, link)) {
+        startIndex -= 1;
+        from -= parent.child(startIndex).nodeSize;
+    }
+    while (endIndex < parent.childCount &&
+        hasSameMark(parent.child(endIndex).marks, link)) {
+        to += parent.child(endIndex).nodeSize;
+        endIndex += 1;
+    }
+    return {
+        from,
+        to,
+        mark: link,
+    };
+}
+function hasSameMark(marks, mark) {
+    return marks.some((candidate) => candidate.eq(mark));
+}
+function createLinkState(state, range) {
+    return {
+        from: range.from,
+        to: range.to,
+        href: range.mark.attrs['href'],
+        target: normalizeTarget(range.mark.attrs['target']),
+        rel: normalizeRel(range.mark.attrs['rel']),
+        text: state.doc.textBetween(range.from, range.to, ''),
+    };
+}
+function resolveLinkAttrs(value, options) {
+    const rawValue = typeof value === 'string'
+        ? { href: value }
+        : isLinkCommandValue(value)
+            ? value
+            : null;
+    if (!rawValue) {
+        return null;
+    }
+    const href = normalizeHref$1(rawValue.href, options);
+    if (!href) {
+        return null;
+    }
+    return {
+        href,
+        target: normalizeTarget(rawValue.target ?? options.defaultTarget),
+        rel: normalizeRel(rawValue.rel ?? options.defaultRel),
+    };
+}
+function normalizeHref$1(value, options) {
+    const href = value?.trim();
+    if (!href) {
+        return null;
+    }
+    const protocol = href.match(/^([a-z][a-z0-9+.-]*):/i)?.[1].toLowerCase();
+    if (!protocol) {
+        return options.allowRelativeLinks ? href : null;
+    }
+    return options.allowedProtocols.includes(protocol) ? href : null;
+}
+function normalizeTarget(value) {
+    return value === '_blank' ? value : null;
+}
+function normalizeRel(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    return value.trim() || null;
+}
+function isLinkCommandValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'href' in value &&
+        typeof value.href === 'string');
+}
+function isLinkElementTarget(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'element' in value &&
+        value.element instanceof HTMLAnchorElement);
+}
+function isLinkRangeTarget(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'from' in value &&
+        'to' in value &&
+        typeof value.from === 'number' &&
+        typeof value.to === 'number');
+}
+function hasLinkBetween(state, mark, from, to) {
+    if (from < 0 || to > state.doc.content.size || from >= to) {
+        return false;
+    }
+    return state.doc.rangeHasMark(from, to, mark);
+}
+function selectionAllowsMark(state, mark) {
+    if (state.selection.empty) {
+        return state.selection.$from.parent.type.allowsMarkType(mark);
+    }
+    return state.selection.ranges.some((range) => {
+        let allowsMark = false;
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, _pos, parent) => {
+            if (allowsMark) {
+                return false;
+            }
+            if (node.isInline && parent?.type.allowsMarkType(mark)) {
+                allowsMark = true;
+                return false;
+            }
+            return undefined;
+        });
+        return allowsMark;
+    });
+}
+function assertLinkPluginOptions(options) {
+    if (!Array.isArray(options.allowedProtocols)) {
+        throw new TypeError('LinkPlugin allowedProtocols must be an array.');
+    }
+    if (options.allowedProtocols.length === 0) {
+        throw new RangeError('LinkPlugin allowedProtocols must include at least one protocol.');
+    }
+    for (const protocol of options.allowedProtocols) {
+        if (typeof protocol !== 'string' ||
+            !/^[a-z][a-z0-9+.-]*$/.test(protocol)) {
+            throw new TypeError('LinkPlugin allowedProtocols entries must be protocol names without colons.');
+        }
+    }
+    if (typeof options.allowRelativeLinks !== 'boolean') {
+        throw new TypeError('LinkPlugin allowRelativeLinks must be a boolean.');
+    }
+    if (options.defaultTarget !== null &&
+        options.defaultTarget !== '_blank') {
+        throw new TypeError('LinkPlugin defaultTarget must be "_blank" or null.');
+    }
+    if (options.defaultRel !== null &&
+        (typeof options.defaultRel !== 'string' || options.defaultRel.trim() === '')) {
+        throw new TypeError('LinkPlugin defaultRel must be a non-empty string or null.');
+    }
+}
+
+const bulletListNode = {
+    ...bulletList,
+    content: 'listItem+',
+    group: 'block',
+};
+const orderedListNode = {
+    ...orderedList,
+    content: 'listItem+',
+    group: 'block',
+};
+const listItemNode = {
+    ...listItem,
+    content: 'paragraph block*',
+};
+const ListsPlugin = createQalmaPlugin({
+    key: 'lists',
+    nodes: {
+        bulletList: bulletListNode,
+        orderedList: orderedListNode,
+        listItem: listItemNode,
+    },
+    commands: (schema) => ({
+        toggleBulletList: createToggleListCommand(schema.nodes['bulletList'], schema.nodes['orderedList'], schema.nodes['listItem']),
+        toggleOrderedList: createToggleListCommand(schema.nodes['orderedList'], schema.nodes['bulletList'], schema.nodes['listItem']),
+        splitListItem: splitListItemKeepMarks(schema.nodes['listItem']),
+        liftListItem: liftListItem(schema.nodes['listItem']),
+        sinkListItem: sinkListItem(schema.nodes['listItem']),
+    }),
+    commandStates: (schema) => ({
+        toggleBulletList: (state) => isClosestListActive(state, [
+            schema.nodes['bulletList'],
+            schema.nodes['orderedList'],
+        ]),
+        toggleOrderedList: (state) => isClosestListActive(state, [
+            schema.nodes['orderedList'],
+            schema.nodes['bulletList'],
+        ]),
+    }),
+    shortcuts: (schema) => ({
+        'Mod-Shift-8': createToggleListCommand(schema.nodes['bulletList'], schema.nodes['orderedList'], schema.nodes['listItem']),
+        'Mod-Shift-7': createToggleListCommand(schema.nodes['orderedList'], schema.nodes['bulletList'], schema.nodes['listItem']),
+        Enter: splitListItemKeepMarks(schema.nodes['listItem']),
+        Tab: createListTabCommand([schema.nodes['bulletList'], schema.nodes['orderedList']], sinkListItem(schema.nodes['listItem'])),
+        'Shift-Tab': createListTabCommand([schema.nodes['bulletList'], schema.nodes['orderedList']], liftListItem(schema.nodes['listItem'])),
+    }),
+    prosemirrorPlugins: () => [createLeaveEditorPlugin()],
+});
+const ListsKit = [ListsPlugin];
+function createToggleListCommand(list, alternateList, listItem) {
+    return (state, dispatch) => {
+        if (isListActive(state, list)) {
+            return liftListItem(listItem)(state, dispatch);
+        }
+        const activeList = findClosestList(state, [list, alternateList]);
+        if (activeList) {
+            if (!list.validContent(activeList.node.content)) {
+                return false;
+            }
+            if (dispatch) {
+                dispatch(state.tr
+                    .setNodeMarkup(activeList.position, list, getListAttrs(list))
+                    .scrollIntoView());
+            }
+            return true;
+        }
+        return wrapInList(list, getListAttrs(list))(state, dispatch);
+    };
+}
+function createListTabCommand(lists, command) {
+    return (state, dispatch, view) => {
+        if (command(state, dispatch, view)) {
+            return true;
+        }
+        return Boolean(findClosestList(state, lists));
+    };
+}
+function createLeaveEditorPlugin() {
+    return new Plugin({
+        props: {
+            handleKeyDown: (view, event) => {
+                if (event.key !== 'Escape') {
+                    return false;
+                }
+                const target = findAdjacentFocusable(view.dom, event.shiftKey ? 'previous' : 'next');
+                event.preventDefault();
+                if (target) {
+                    target.focus();
+                }
+                else {
+                    view.dom.blur();
+                }
+                return true;
+            },
+        },
+    });
+}
+function findClosestList(state, listTypes) {
+    const { $from } = state.selection;
+    for (let depth = $from.depth; depth > 0; depth -= 1) {
+        const node = $from.node(depth);
+        if (listTypes.includes(node.type)) {
+            return {
+                node,
+                position: $from.before(depth),
+            };
+        }
+    }
+    return null;
+}
+function isListActive(state, list) {
+    return Boolean(findClosestList(state, [list]));
+}
+function isClosestListActive(state, [list, alternateList]) {
+    return findClosestList(state, [list, alternateList])?.node.type === list;
+}
+function getListAttrs(list) {
+    return list.name === 'orderedList' ? { order: 1 } : null;
+}
+const focusableSelector = [
+    'a[href]',
+    'button:not([disabled])',
+    'input:not([disabled])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    '[contenteditable="true"]',
+    '[tabindex]:not([tabindex="-1"])',
+].join(',');
+function findAdjacentFocusable(editor, direction) {
+    const root = editor.getRootNode();
+    if (!(root instanceof Document || root instanceof ShadowRoot)) {
+        return null;
+    }
+    const focusableElements = Array.from(root.querySelectorAll(focusableSelector)).filter((element) => isFocusable(element) && !editor.contains(element));
+    const orderedElements = direction === 'next' ? focusableElements : focusableElements.reverse();
+    return (orderedElements.find((element) => direction === 'next'
+        ? isAfterEditor(editor, element)
+        : isBeforeEditor(editor, element)) ?? null);
+}
+function isFocusable(element) {
+    if (element.hidden || element.closest('[inert]')) {
+        return false;
+    }
+    const style = getComputedStyle(element);
+    return style.display !== 'none' && style.visibility !== 'hidden';
+}
+function isAfterEditor(editor, element) {
+    return Boolean(editor.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING);
+}
+function isBeforeEditor(editor, element) {
+    return Boolean(editor.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+
+const MENTION_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    trigger: '@',
+    minQueryLength: 0,
+    maxQueryLength: 64,
+    appendSpaceOnInsert: true,
+});
+const MentionPlugin = createConfigurableQalmaPlugin(MENTION_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertMentionPluginOptions(options);
+    const mentionNode = {
+        attrs: {
+            id: {},
+            label: {},
+            trigger: { default: options.trigger },
+        },
+        group: 'inline',
+        inline: true,
+        atom: true,
+        selectable: false,
+        parseDOM: [
+            {
+                tag: 'span[data-qalma-mention]',
+                getAttrs: (node) => {
+                    if (!(node instanceof HTMLElement)) {
+                        return false;
+                    }
+                    const id = normalizeMentionText(node.dataset['mentionId']);
+                    const trigger = normalizeTrigger(node.dataset['mentionTrigger'] ?? options.trigger);
+                    const label = normalizeMentionText(node.dataset['mentionLabel'] ??
+                        stripMentionTrigger(node.textContent ?? '', trigger));
+                    return id && label
+                        ? {
+                            id,
+                            label,
+                            trigger,
+                        }
+                        : false;
+                },
+            },
+        ],
+        toDOM: (node) => {
+            const trigger = normalizeTrigger(node.attrs['trigger']);
+            const label = normalizeMentionText(node.attrs['label']) ?? '';
+            const attrs = {
+                'data-qalma-mention': '',
+                'data-mention-id': String(node.attrs['id']),
+                'data-mention-label': label,
+                'data-mention-trigger': trigger,
+                contenteditable: 'false',
+            };
+            return ['span', attrs, `${trigger}${label}`];
+        },
+    };
+    return createQalmaPlugin({
+        key: 'mention',
+        nodes: {
+            mention: mentionNode,
+        },
+        commands: (schema) => ({
+            insertMention: createInsertMentionCommand(schema.nodes['mention'], options),
+        }),
+        queries: () => ({
+            mention: (state) => getMentionState(state, options),
+        }),
+        prosemirrorPlugins: () => [createMentionInteractionPlugin(options)],
+    });
+});
+const MentionKit = [MentionPlugin];
+function createInsertMentionCommand(mention, options) {
+    return (state, dispatch, _view, value) => {
+        const attrs = resolveMentionAttrs(value, options);
+        const range = getMentionState(state, options) ?? {
+            from: state.selection.from,
+            to: state.selection.to,
+            query: '',
+            trigger: attrs?.trigger ?? options.trigger,
+        };
+        if (!attrs || !selectionAllowsMention(state, mention, range.from, range.to)) {
+            return false;
+        }
+        if (dispatch) {
+            const mentionNode = mention.create(attrs);
+            const nextCharacter = state.doc.textBetween(range.to, Math.min(range.to + 1, state.doc.content.size), '', '');
+            const shouldAppendSpace = options.appendSpaceOnInsert && !/^\s$/.test(nextCharacter);
+            let transaction = state.tr.replaceWith(range.from, range.to, mentionNode);
+            const selectionPosition = range.from + mentionNode.nodeSize;
+            if (shouldAppendSpace) {
+                transaction = transaction.insertText(' ', selectionPosition);
+            }
+            dispatch(transaction
+                .setSelection(TextSelection.create(transaction.doc, selectionPosition))
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+function createMentionInteractionPlugin(options) {
+    return new Plugin({
+        props: {
+            handleKeyDown: (view, event) => {
+                if (!getMentionState(view.state, options) ||
+                    !isMentionNavigationKey(event.key)) {
+                    return false;
+                }
+                const mentionEvent = new CustomEvent('qalma-mention-keydown', {
+                    bubbles: true,
+                    cancelable: true,
+                    detail: {
+                        key: event.key,
+                    },
+                });
+                view.dom.dispatchEvent(mentionEvent);
+                if (!mentionEvent.defaultPrevented) {
+                    return false;
+                }
+                event.preventDefault();
+                return true;
+            },
+        },
+        view: (view) => ({
+            update: () => {
+                view.dom.dispatchEvent(new CustomEvent('qalma-mention-update', {
+                    bubbles: true,
+                }));
+            },
+        }),
+    });
+}
+function isMentionNavigationKey(key) {
+    return (key === 'ArrowDown' ||
+        key === 'ArrowUp' ||
+        key === 'Escape' ||
+        key === 'Enter' ||
+        key === 'Tab' ||
+        key === ' ' ||
+        key === 'Spacebar');
+}
+function getMentionState(state, options) {
+    if (!state.selection.empty) {
+        return null;
+    }
+    const $cursor = state.selection.$from;
+    if (isCodeTextblock($cursor.parent.type)) {
+        return null;
+    }
+    const textBeforeCursor = $cursor.parent.textBetween(0, $cursor.parentOffset, '', '');
+    const triggerIndex = textBeforeCursor.lastIndexOf(options.trigger);
+    if (triggerIndex < 0 || !hasMentionBoundary(textBeforeCursor, triggerIndex)) {
+        return null;
+    }
+    const query = textBeforeCursor.slice(triggerIndex + options.trigger.length);
+    if (/\s/.test(query) ||
+        query.length < options.minQueryLength ||
+        query.length > options.maxQueryLength) {
+        return null;
+    }
+    return {
+        from: $cursor.start() + triggerIndex,
+        to: state.selection.from,
+        query,
+        trigger: options.trigger,
+    };
+}
+function hasMentionBoundary(text, triggerIndex) {
+    return triggerIndex === 0 || /\s/.test(text.charAt(triggerIndex - 1));
+}
+function resolveMentionAttrs(value, options) {
+    if (!isMentionCommandValue(value)) {
+        return null;
+    }
+    const id = normalizeMentionText(value.id);
+    const label = normalizeMentionText(value.label);
+    const trigger = normalizeTrigger(value.trigger ?? options.trigger);
+    return id && label
+        ? {
+            id,
+            label,
+            trigger,
+        }
+        : null;
+}
+function isMentionCommandValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'id' in value &&
+        'label' in value &&
+        typeof value.id === 'string' &&
+        typeof value.label === 'string' &&
+        (!('trigger' in value) ||
+            value.trigger === undefined ||
+            typeof value.trigger === 'string'));
+}
+function selectionAllowsMention(state, mention, from, to) {
+    if (from < 0 || to > state.doc.content.size || from > to) {
+        return false;
+    }
+    const $from = state.doc.resolve(from);
+    const $to = state.doc.resolve(to);
+    return (!isCodeTextblock($from.parent.type) &&
+        $from.sameParent($to) &&
+        $from.parent.canReplaceWith($from.index(), $to.index(), mention));
+}
+function isCodeTextblock(type) {
+    return Boolean(type.spec.code);
+}
+function normalizeMentionText(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    return value.trim() || null;
+}
+function normalizeTrigger(value) {
+    return typeof value === 'string' && value.length > 0 ? value : '@';
+}
+function stripMentionTrigger(text, trigger) {
+    return text.startsWith(trigger) ? text.slice(trigger.length) : text;
+}
+function assertMentionPluginOptions(options) {
+    if (typeof options.trigger !== 'string' ||
+        Array.from(options.trigger).length !== 1 ||
+        /\s/.test(options.trigger)) {
+        throw new TypeError('MentionPlugin trigger must be a single non-whitespace character.');
+    }
+    if (!Number.isInteger(options.minQueryLength) ||
+        options.minQueryLength < 0) {
+        throw new RangeError('MentionPlugin minQueryLength must be a non-negative integer.');
+    }
+    if (!Number.isInteger(options.maxQueryLength) ||
+        options.maxQueryLength < options.minQueryLength) {
+        throw new RangeError('MentionPlugin maxQueryLength must be greater than or equal to minQueryLength.');
+    }
+    if (typeof options.appendSpaceOnInsert !== 'boolean') {
+        throw new TypeError('MentionPlugin appendSpaceOnInsert must be a boolean.');
+    }
+}
+
+const PASTE_RULES_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    autolink: true,
+    allowedProtocols: Object.freeze(['http', 'https', 'mailto', 'tel']),
+    allowRelativeLinks: true,
+    cleanHtml: true,
+    defaultProtocol: 'https',
+});
+const PasteRulesPlugin = createConfigurableQalmaPlugin(PASTE_RULES_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertPasteRulesPluginOptions(options);
+    return createQalmaPlugin({
+        key: 'pasteRules',
+        prosemirrorPlugins: (schema) => [
+            createPasteRulesPlugin(schema, options),
+        ],
+    });
+});
+function createPasteRulesPlugin(schema, options) {
+    return new Plugin({
+        props: {
+            handlePaste: (view, event) => {
+                const clipboardData = event.clipboardData;
+                if (!clipboardData) {
+                    return false;
+                }
+                const html = createPasteHtml(clipboardData, schema, options);
+                if (!html) {
+                    return false;
+                }
+                const container = document.createElement('div');
+                container.innerHTML = html;
+                event.preventDefault();
+                view.dispatch(view.state.tr
+                    .replaceSelection(DOMParser.fromSchema(view.state.schema).parseSlice(container, { preserveWhitespace: true }))
+                    .scrollIntoView());
+                return true;
+            },
+        },
+    });
+}
+function createPasteHtml(clipboardData, schema, options) {
+    const html = clipboardData.getData('text/html');
+    const text = clipboardData.getData('text/plain');
+    if (html && !options.cleanHtml) {
+        return null;
+    }
+    if (html) {
+        const cleanedHtml = cleanPastedHtml(html, options);
+        const clipboardHref = getClipboardHref(clipboardData, options);
+        if (schema.marks['link'] &&
+            clipboardHref &&
+            !hasAnchor(cleanedHtml) &&
+            hasEquivalentText(cleanedHtml, text)) {
+            return createLinkedTextHtml(text, clipboardHref);
+        }
+        return cleanedHtml;
+    }
+    if (!options.autolink || !schema.marks['link']) {
+        return null;
+    }
+    return createAutolinkHtml(text, options);
+}
+function cleanPastedHtml(html, options) {
+    const source = document.implementation.createHTMLDocument('');
+    const target = document.createElement('div');
+    source.body.innerHTML = html;
+    for (const child of Array.from(source.body.childNodes)) {
+        appendCleanNode(target, child, options);
+    }
+    return target.innerHTML;
+}
+function appendCleanNode(parent, source, options) {
+    const cleanNode = createCleanNode(source, options);
+    if (cleanNode) {
+        parent.appendChild(cleanNode);
+    }
+}
+function createCleanNode(source, options) {
+    if (source.nodeType === Node.TEXT_NODE) {
+        return document.createTextNode(source.textContent ?? '');
+    }
+    if (!(source instanceof HTMLElement)) {
+        return null;
+    }
+    const tagName = source.tagName.toLowerCase();
+    if (tagName === 'script' || tagName === 'style') {
+        return null;
+    }
+    if (tagName === 'br') {
+        return document.createElement('br');
+    }
+    if (tagName === 'a') {
+        return createCleanLink(source, options);
+    }
+    if (shouldUnwrapElement(tagName)) {
+        return createCleanFragment(source, options);
+    }
+    if (!isAllowedElement(tagName)) {
+        return createCleanFragment(source, options);
+    }
+    const element = document.createElement(tagName);
+    for (const child of Array.from(source.childNodes)) {
+        appendCleanNode(element, child, options);
+    }
+    return element;
+}
+function createCleanLink(source, options) {
+    const href = normalizeHref(source.getAttribute('href') ?? '', options);
+    if (!href) {
+        return createCleanFragment(source, options);
+    }
+    const link = document.createElement('a');
+    link.setAttribute('href', href);
+    for (const child of Array.from(source.childNodes)) {
+        appendCleanNode(link, child, options);
+    }
+    if (!link.textContent) {
+        link.textContent = href;
+    }
+    return link;
+}
+function createCleanFragment(source, options) {
+    const fragment = document.createDocumentFragment();
+    for (const child of Array.from(source.childNodes)) {
+        appendCleanNode(fragment, child, options);
+    }
+    return fragment;
+}
+function shouldUnwrapElement(tagName) {
+    return (tagName === 'html' ||
+        tagName === 'body' ||
+        tagName === 'span' ||
+        tagName === 'font');
+}
+function isAllowedElement(tagName) {
+    return [
+        'blockquote',
+        'code',
+        'del',
+        'em',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'i',
+        'li',
+        'mark',
+        'ol',
+        'p',
+        'pre',
+        's',
+        'strike',
+        'strong',
+        'sub',
+        'sup',
+        'u',
+        'ul',
+    ].includes(tagName);
+}
+function hasAnchor(html) {
+    const container = document.createElement('div');
+    container.innerHTML = html;
+    return Boolean(container.querySelector('a[href]'));
+}
+function hasEquivalentText(html, text) {
+    const container = document.createElement('div');
+    container.innerHTML = html;
+    return normalizeText(container.textContent) === normalizeText(text);
+}
+function normalizeText(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+function getClipboardHref(clipboardData, options) {
+    const uriList = clipboardData
+        .getData('text/uri-list')
+        .split(/\r?\n/)
+        .find((line) => line && !line.startsWith('#'));
+    const normalizedUriList = normalizeHref(uriList ?? '', options);
+    if (normalizedUriList) {
+        return normalizedUriList;
+    }
+    const text = clipboardData.getData('text/plain').trim();
+    if (!isHrefLikeText(text)) {
+        return null;
+    }
+    return normalizeHref(text, options);
+}
+function isHrefLikeText(text) {
+    return (/^(?:[a-z][a-z0-9+.-]*:|www\.|\/|#)/i.test(text) && !/\s/.test(text));
+}
+function createLinkedTextHtml(text, href) {
+    if (!text.trim()) {
+        return null;
+    }
+    return text
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => `<p><a href="${escapeAttribute(href)}">${escapeHtml(line)}</a></p>`)
+        .join('');
+}
+function createAutolinkHtml(text, options) {
+    if (!text.trim()) {
+        return null;
+    }
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const htmlLines = lines.map((line) => autolinkLine(line, options));
+    if (!htmlLines.some((line) => line.changed)) {
+        return null;
+    }
+    return htmlLines
+        .map((line) => `<p>${line.html || '<br>'}</p>`)
+        .join('');
+}
+function autolinkLine(line, options) {
+    const pattern = /(?:https?:\/\/|mailto:|tel:|www\.)[^\s<>"']+/gi;
+    let html = '';
+    let changed = false;
+    let position = 0;
+    for (const match of line.matchAll(pattern)) {
+        const rawMatch = match[0];
+        const index = match.index ?? 0;
+        const candidate = trimTrailingPunctuation(rawMatch);
+        const href = normalizeHref(candidate.text, options);
+        if (!href) {
+            continue;
+        }
+        html += escapeHtml(line.slice(position, index));
+        html += `<a href="${escapeAttribute(href)}">${escapeHtml(candidate.text)}</a>`;
+        html += escapeHtml(candidate.trailing);
+        position = index + rawMatch.length;
+        changed = true;
+    }
+    html += escapeHtml(line.slice(position));
+    return {
+        changed,
+        html,
+    };
+}
+function trimTrailingPunctuation(text) {
+    let candidate = text;
+    let trailing = '';
+    while (/[.,;:!?]$/.test(candidate)) {
+        trailing = `${candidate[candidate.length - 1] ?? ''}${trailing}`;
+        candidate = candidate.slice(0, -1);
+    }
+    while (/[)\]}]$/.test(candidate) && hasUnmatchedClosingPunctuation(candidate)) {
+        trailing = `${candidate[candidate.length - 1] ?? ''}${trailing}`;
+        candidate = candidate.slice(0, -1);
+    }
+    return {
+        text: candidate,
+        trailing,
+    };
+}
+function hasUnmatchedClosingPunctuation(value) {
+    const last = value[value.length - 1];
+    if (last === ')') {
+        return countCharacters(value, ')') > countCharacters(value, '(');
+    }
+    if (last === ']') {
+        return countCharacters(value, ']') > countCharacters(value, '[');
+    }
+    if (last === '}') {
+        return countCharacters(value, '}') > countCharacters(value, '{');
+    }
+    return false;
+}
+function countCharacters(value, character) {
+    return Array.from(value).filter((candidate) => candidate === character)
+        .length;
+}
+function normalizeHref(text, options) {
+    if (!text) {
+        return null;
+    }
+    const href = text.toLowerCase().startsWith('www.')
+        ? `${options.defaultProtocol}://${text}`
+        : text;
+    const protocol = href.match(/^([a-z][a-z0-9+.-]*):/i)?.[1].toLowerCase();
+    if (!protocol) {
+        return options.allowRelativeLinks ? href : null;
+    }
+    if (!options.allowedProtocols.includes(protocol)) {
+        return null;
+    }
+    return href;
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replace(/"/g, '&quot;');
+}
+function assertPasteRulesPluginOptions(options) {
+    if (typeof options.autolink !== 'boolean') {
+        throw new TypeError('PasteRulesPlugin autolink must be a boolean.');
+    }
+    if (!Array.isArray(options.allowedProtocols)) {
+        throw new TypeError('PasteRulesPlugin allowedProtocols must be an array.');
+    }
+    if (options.allowedProtocols.length === 0) {
+        throw new RangeError('PasteRulesPlugin allowedProtocols must include at least one protocol.');
+    }
+    for (const protocol of options.allowedProtocols) {
+        if (typeof protocol !== 'string' ||
+            !/^[a-z][a-z0-9+.-]*$/.test(protocol)) {
+            throw new TypeError('PasteRulesPlugin allowedProtocols entries must be protocol names without colons.');
+        }
+    }
+    if (typeof options.allowRelativeLinks !== 'boolean') {
+        throw new TypeError('PasteRulesPlugin allowRelativeLinks must be a boolean.');
+    }
+    if (typeof options.cleanHtml !== 'boolean') {
+        throw new TypeError('PasteRulesPlugin cleanHtml must be a boolean.');
+    }
+    if (options.defaultProtocol !== 'http' && options.defaultProtocol !== 'https') {
+        throw new TypeError('PasteRulesPlugin defaultProtocol must be "http" or "https".');
+    }
+    if (!options.allowedProtocols.includes(options.defaultProtocol)) {
+        throw new Error('PasteRulesPlugin defaultProtocol must be included in allowedProtocols.');
+    }
+}
+
+const PLACEHOLDER_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    placeholder: 'Write something...',
+    className: 'qalma-placeholder',
+});
+const PlaceholderPlugin = createConfigurableQalmaPlugin(PLACEHOLDER_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertPlaceholderPluginOptions(options);
+    return createQalmaPlugin({
+        key: 'placeholder',
+        prosemirrorPlugins: () => [createPlaceholderProseMirrorPlugin(options)],
+    });
+});
+const PlaceholderKit = [PlaceholderPlugin];
+function createPlaceholderProseMirrorPlugin(options) {
+    return new Plugin({
+        props: {
+            decorations: (state) => {
+                const target = getPlaceholderTarget(state.doc);
+                if (!target) {
+                    return DecorationSet.empty;
+                }
+                return DecorationSet.create(state.doc, [
+                    Decoration.node(target.from, target.to, {
+                        class: options.className,
+                        'data-placeholder': options.placeholder,
+                    }),
+                ]);
+            },
+        },
+    });
+}
+function getPlaceholderTarget(doc) {
+    if (doc.childCount !== 1) {
+        return null;
+    }
+    const node = doc.child(0);
+    if (!node.isTextblock || node.content.size > 0) {
+        return null;
+    }
+    return {
+        from: 0,
+        to: node.nodeSize,
+    };
+}
+function assertPlaceholderPluginOptions(options) {
+    if (typeof options.placeholder !== 'string' ||
+        options.placeholder.trim().length === 0) {
+        throw new Error('PlaceholderPlugin placeholder must be a non-empty string.');
+    }
+    if (typeof options.className !== 'string' ||
+        options.className.trim().length === 0 ||
+        /\s/.test(options.className)) {
+        throw new Error('PlaceholderPlugin className must be a non-empty CSS class name.');
+    }
+}
+
+const subscriptMark = {
+    excludes: 'superscript',
+    parseDOM: [
+        { tag: 'sub' },
+        {
+            style: 'vertical-align',
+            getAttrs: (value) => (String(value) === 'sub' ? null : false),
+        },
+    ],
+    toDOM: () => ['sub', 0],
+};
+const superscriptMark = {
+    excludes: 'subscript',
+    parseDOM: [
+        { tag: 'sup' },
+        {
+            style: 'vertical-align',
+            getAttrs: (value) => (String(value) === 'super' ? null : false),
+        },
+    ],
+    toDOM: () => ['sup', 0],
+};
+const SubscriptSuperscriptPlugin = createQalmaPlugin({
+    key: 'subscriptSuperscript',
+    marks: {
+        subscript: subscriptMark,
+        superscript: superscriptMark,
+    },
+    commands: (schema) => ({
+        toggleSubscript: toggleMark(schema.marks['subscript']),
+        toggleSuperscript: toggleMark(schema.marks['superscript']),
+    }),
+    commandStates: (schema) => ({
+        toggleSubscript: (state) => isMarkActive(state, schema.marks['subscript']),
+        toggleSuperscript: (state) => isMarkActive(state, schema.marks['superscript']),
+    }),
+});
+const SubscriptSuperscriptKit = [
+    SubscriptSuperscriptPlugin,
+];
+
+const TEXT_ALIGNMENTS = Object.freeze([
+    'left',
+    'center',
+    'right',
+    'justify',
+]);
+const TEXT_ALIGN_NODES = Object.freeze([
+    'paragraph',
+    'heading',
+    'listItem',
+    'blockquote',
+]);
+const TEXT_ALIGN_PLUGIN_DEFAULT_OPTIONS = Object.freeze({
+    alignments: TEXT_ALIGNMENTS,
+    nodes: TEXT_ALIGN_NODES,
+});
+const TextAlignPlugin = createConfigurableQalmaPlugin(TEXT_ALIGN_PLUGIN_DEFAULT_OPTIONS, (options) => {
+    assertTextAlignPluginOptions(options);
+    return createQalmaPlugin({
+        key: 'textAlign',
+        extendNodes: (nodes) => createTextAlignNodeExtensions(nodes, options),
+        commands: (schema) => createTextAlignCommands(schema, options.alignments, options.nodes),
+        commandStates: (schema) => createTextAlignCommandStates(schema, options.alignments, options.nodes),
+        queries: (schema) => ({
+            textAlign: (state) => getActiveTextAlign(state, getNodeTypes(schema, options.nodes)),
+        }),
+    });
+});
+const TextAlignKit = [TextAlignPlugin];
+function createTextAlignNodeExtensions(nodes, options) {
+    return Object.fromEntries(options.nodes
+        .filter((nodeName) => nodes[nodeName])
+        .map((nodeName) => [
+        nodeName,
+        extendNodeSpecWithTextAlign(nodes[nodeName]),
+    ]));
+}
+function extendNodeSpecWithTextAlign(nodeSpec) {
+    return {
+        ...nodeSpec,
+        attrs: {
+            ...nodeSpec.attrs,
+            textAlign: { default: null },
+        },
+        parseDOM: nodeSpec.parseDOM?.map((rule) => extendParseRuleWithTextAlign(rule)),
+        toDOM: (node) => addTextAlignToDomSpec(nodeSpec.toDOM?.(node) ?? ['div', 0], parseTextAlignment(node.attrs['textAlign'])),
+    };
+}
+function extendParseRuleWithTextAlign(rule) {
+    return {
+        ...rule,
+        getAttrs: (dom) => {
+            const attrs = getParseRuleAttrs(rule, dom);
+            if (attrs === false) {
+                return false;
+            }
+            return {
+                ...(attrs ?? {}),
+                textAlign: getTextAlignFromDom(dom),
+            };
+        },
+    };
+}
+function getParseRuleAttrs(rule, dom) {
+    const attrs = rule.getAttrs ? rule.getAttrs(dom) : (rule.attrs ?? null);
+    return attrs === false || attrs === null ? attrs : { ...attrs };
+}
+function getTextAlignFromDom(dom) {
+    return parseTextAlignment(dom.style.textAlign || dom.getAttribute('align'));
+}
+function addTextAlignToDomSpec(domSpec, alignment) {
+    if (!alignment || alignment === 'left' || !Array.isArray(domSpec)) {
+        return domSpec;
+    }
+    const [tagName, maybeAttrs, ...children] = domSpec;
+    const textAlignStyle = `text-align: ${alignment};`;
+    if (isDomAttrs(maybeAttrs)) {
+        return [
+            tagName,
+            {
+                ...maybeAttrs,
+                style: joinStyles(maybeAttrs['style'], textAlignStyle),
+            },
+            ...children,
+        ];
+    }
+    return [tagName, { style: textAlignStyle }, maybeAttrs, ...children];
+}
+function isDomAttrs(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !('nodeType' in value));
+}
+function joinStyles(existingStyle, textAlignStyle) {
+    return existingStyle
+        ? `${existingStyle.replace(/;?\s*$/, ';')} ${textAlignStyle}`
+        : textAlignStyle;
+}
+function createTextAlignCommands(schema, alignments, nodes) {
+    const nodeTypes = getNodeTypes(schema, nodes);
+    return Object.fromEntries(alignments.map((alignment) => [
+        getTextAlignCommandName(alignment),
+        createSetTextAlignCommand(nodeTypes, alignment),
+    ]));
+}
+function createTextAlignCommandStates(schema, alignments, nodes) {
+    const nodeTypes = getNodeTypes(schema, nodes);
+    return Object.fromEntries(alignments.map((alignment) => [
+        getTextAlignCommandName(alignment),
+        (state) => getActiveTextAlign(state, nodeTypes) === alignment,
+    ]));
+}
+function createSetTextAlignCommand(nodeTypes, alignment) {
+    return (state, dispatch) => {
+        const targets = getSelectedAlignmentTargets(state, nodeTypes);
+        if (targets.length === 0) {
+            return false;
+        }
+        if (dispatch) {
+            const transaction = state.tr;
+            const textAlign = alignment === 'left' ? null : alignment;
+            for (const target of targets) {
+                transaction.setNodeMarkup(target.position, undefined, {
+                    ...target.node.attrs,
+                    textAlign,
+                });
+            }
+            dispatch(transaction.scrollIntoView());
+        }
+        return true;
+    };
+}
+function getSelectedAlignmentTargets(state, nodeTypes) {
+    if (nodeTypes.length === 0) {
+        return [];
+    }
+    if (state.selection.empty) {
+        const target = findAlignmentTarget(state.selection.$from, nodeTypes);
+        return target ? [target] : [];
+    }
+    const targets = new Map();
+    for (const range of state.selection.ranges) {
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, position) => {
+            if (!node.isTextblock && !nodeTypes.includes(node.type)) {
+                return undefined;
+            }
+            const target = findAlignmentTarget(state.doc.resolve(position + 1), nodeTypes);
+            if (target) {
+                targets.set(target.position, target);
+            }
+            if (nodeTypes.includes(node.type)) {
+                return false;
+            }
+            return undefined;
+        });
+    }
+    return Array.from(targets.values());
+}
+function findAlignmentTarget($pos, nodeTypes) {
+    let textblockTarget = null;
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+        const node = $pos.node(depth);
+        if (!nodeTypes.includes(node.type)) {
+            continue;
+        }
+        const target = { node, position: $pos.before(depth) };
+        if (!node.isTextblock) {
+            return target;
+        }
+        textblockTarget = target;
+    }
+    return textblockTarget;
+}
+function getActiveTextAlign(state, nodeTypes) {
+    const target = getSelectedAlignmentTargets(state, nodeTypes)[0];
+    return target ? getNodeTextAlign(target.node) : null;
+}
+function getNodeTextAlign(node) {
+    return parseTextAlignment(node.attrs['textAlign']) ?? 'left';
+}
+function getNodeTypes(schema, nodeNames) {
+    return nodeNames
+        .map((nodeName) => schema.nodes[nodeName])
+        .filter((node) => Boolean(node));
+}
+function getTextAlignCommandName(alignment) {
+    return `setTextAlign${alignment[0].toUpperCase()}${alignment.slice(1)}`;
+}
+function parseTextAlignment(value) {
+    return TEXT_ALIGNMENTS.includes(value)
+        ? value
+        : null;
+}
+function assertTextAlignPluginOptions(options) {
+    assertUniqueOptionEntries(options.alignments, TEXT_ALIGNMENTS, 'TextAlignPlugin alignments');
+    assertUniqueOptionEntries(options.nodes, TEXT_ALIGN_NODES, 'TextAlignPlugin nodes');
+}
+function assertUniqueOptionEntries(values, allowedValues, optionName) {
+    if (!Array.isArray(values)) {
+        throw new TypeError(`${optionName} must be an array.`);
+    }
+    if (values.length === 0) {
+        throw new RangeError(`${optionName} must include at least one value.`);
+    }
+    const seen = new Set();
+    for (const value of values) {
+        if (!allowedValues.includes(value)) {
+            throw new RangeError(`${optionName} entries include an unsupported value.`);
+        }
+        if (seen.has(value)) {
+            throw new Error(`${optionName} entries must be unique.`);
+        }
+        seen.add(value);
+    }
+}
+
+const strongMark = {
+    parseDOM: [
+        { tag: 'strong' },
+        { tag: 'b' },
+        {
+            style: 'font-weight',
+            getAttrs: (value) => {
+                const weight = String(value);
+                return weight === 'bold' || weight === 'bolder' || Number(weight) >= 500
+                    ? null
+                    : false;
+            },
+        },
+    ],
+    toDOM: () => ['strong', 0],
+};
+const emMark = {
+    parseDOM: [{ tag: 'em' }, { tag: 'i' }, { style: 'font-style=italic' }],
+    toDOM: () => ['em', 0],
+};
+const underlineMark = {
+    parseDOM: [
+        { tag: 'u' },
+        {
+            style: 'text-decoration',
+            getAttrs: (value) => (String(value).includes('underline') ? null : false),
+        },
+    ],
+    toDOM: () => ['u', 0],
+};
+const strikeMark = {
+    parseDOM: [
+        { tag: 's' },
+        { tag: 'strike' },
+        { tag: 'del' },
+        {
+            style: 'text-decoration',
+            getAttrs: (value) => String(value).includes('line-through') ? null : false,
+        },
+    ],
+    toDOM: () => ['s', 0],
+};
+const BoldPlugin = createQalmaPlugin({
+    key: 'bold',
+    marks: {
+        strong: strongMark,
+    },
+    commands: (schema) => ({
+        toggleBold: toggleMark(schema.marks['strong']),
+    }),
+    commandStates: (schema) => ({
+        toggleBold: (state) => isMarkActive(state, schema.marks['strong']),
+    }),
+    shortcuts: (schema) => ({
+        'Mod-b': toggleMark(schema.marks['strong']),
+    }),
+});
+const ItalicPlugin = createQalmaPlugin({
+    key: 'italic',
+    marks: {
+        em: emMark,
+    },
+    commands: (schema) => ({
+        toggleItalic: toggleMark(schema.marks['em']),
+    }),
+    commandStates: (schema) => ({
+        toggleItalic: (state) => isMarkActive(state, schema.marks['em']),
+    }),
+    shortcuts: (schema) => ({
+        'Mod-i': toggleMark(schema.marks['em']),
+    }),
+});
+const UnderlinePlugin = createQalmaPlugin({
+    key: 'underline',
+    marks: {
+        underline: underlineMark,
+    },
+    commands: (schema) => ({
+        toggleUnderline: toggleMark(schema.marks['underline']),
+    }),
+    commandStates: (schema) => ({
+        toggleUnderline: (state) => isMarkActive(state, schema.marks['underline']),
+    }),
+    shortcuts: (schema) => ({
+        'Mod-u': toggleMark(schema.marks['underline']),
+    }),
+});
+const StrikePlugin = createQalmaPlugin({
+    key: 'strike',
+    marks: {
+        strike: strikeMark,
+    },
+    commands: (schema) => ({
+        toggleStrike: toggleMark(schema.marks['strike']),
+    }),
+    commandStates: (schema) => ({
+        toggleStrike: (state) => isMarkActive(state, schema.marks['strike']),
+    }),
+});
+const TextFormattingKit = [
+    BoldPlugin,
+    ItalicPlugin,
+    UnderlinePlugin,
+    StrikePlugin,
+];
+
+const TrailingParagraphPlugin = createQalmaPlugin({
+    key: 'trailingParagraph',
+    prosemirrorPlugins: (schema) => [
+        createTrailingParagraphProseMirrorPlugin(schema.nodes['paragraph']),
+    ],
+});
+const TrailingParagraphKit = [
+    TrailingParagraphPlugin,
+];
+function createTrailingParagraphProseMirrorPlugin(paragraph) {
+    return new Plugin({
+        appendTransaction: (_transactions, _oldState, newState) => createTrailingParagraphTransaction(newState, paragraph),
+        view: (view) => {
+            queueTrailingParagraphUpdate(view, paragraph);
+            return {
+                update: (updatedView) => queueTrailingParagraphUpdate(updatedView, paragraph),
+            };
+        },
+    });
+}
+function queueTrailingParagraphUpdate(view, paragraph) {
+    queueMicrotask(() => {
+        if (view.isDestroyed) {
+            return;
+        }
+        const transaction = createTrailingParagraphTransaction(view.state, paragraph);
+        if (transaction) {
+            view.dispatch(transaction);
+        }
+    });
+}
+function createTrailingParagraphTransaction(state, paragraph) {
+    const lastChild = state.doc.lastChild;
+    if (lastChild?.type === paragraph &&
+        lastChild.isTextblock &&
+        lastChild.content.size === 0) {
+        return null;
+    }
+    const paragraphNode = paragraph.createAndFill();
+    if (!paragraphNode ||
+        !state.doc.canReplaceWith(state.doc.childCount, state.doc.childCount, paragraph)) {
+        return null;
+    }
+    return state.tr
+        .insert(state.doc.content.size, paragraphNode)
+        .setMeta('addToHistory', false);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BlockquoteKit, BlockquotePlugin, BoldPlugin, CODE_BLOCK_PLUGIN_DEFAULT_OPTIONS, ClearFormattingKit, ClearFormattingPlugin, CodeBlockKit, CodeBlockPlugin, ColorKit, ColorPlugin, HEADINGS_PLUGIN_DEFAULT_OPTIONS, HEADING_LEVELS, HIGHLIGHT_PLUGIN_DEFAULT_OPTIONS, HISTORY_PLUGIN_DEFAULT_OPTIONS, HardBreakKit, HardBreakPlugin, HeadingsKit, HeadingsPlugin, HighlightKit, HighlightPlugin, HistoryPlugin, IMAGE_PLUGIN_DEFAULT_OPTIONS, ImageKit, ImagePlugin, ItalicPlugin, LINK_PLUGIN_DEFAULT_OPTIONS, LinkPlugin, ListsKit, ListsPlugin, MENTION_PLUGIN_DEFAULT_OPTIONS, MentionKit, MentionPlugin, PASTE_RULES_PLUGIN_DEFAULT_OPTIONS, PLACEHOLDER_PLUGIN_DEFAULT_OPTIONS, PasteRulesPlugin, PlaceholderKit, PlaceholderPlugin, QalmaCommand, QalmaContent, QalmaEditor, QalmaEditorController, QalmaToolbar, StrikePlugin, SubscriptSuperscriptKit, SubscriptSuperscriptPlugin, TEXT_ALIGNMENTS, TEXT_ALIGN_NODES, TEXT_ALIGN_PLUGIN_DEFAULT_OPTIONS, TextAlignKit, TextAlignPlugin, TextFormattingKit, TrailingParagraphKit, TrailingParagraphPlugin, UnderlinePlugin, createConfigurableQalmaPlugin, createQalmaEditor, createQalmaPlugin };
+//# sourceMappingURL=qalma-editor.mjs.map