@aicayzer/inkkit 0.0.18 → 0.1.1

package/dist/editor.js

@@ -1,2673 +0,0 @@
-import { Editor, commandsCtx, defaultValueCtx, editorViewCtx, parserCtx, editorViewOptionsCtx, remarkCtx, remarkStringifyOptionsCtx, rootCtx, } from '@milkdown/kit/core';
-import { visibleClipboard, portableClipboard, clipboardText, clipboardContent, } from './clipboard.js';
-import { clipboard } from '@milkdown/kit/plugin/clipboard';
-import { history, historyKeymap } from '@milkdown/kit/plugin/history';
-import { closeHistory, undo as undoHistory, redo as redoHistory, } from '@milkdown/kit/prose/history';
-import { cursor } from './cursor.js';
-import { blockDropRange } from './drop-placement.js';
-import { blockquoteKeymap, blockquoteSchema, bulletListKeymap, codeBlockKeymap, createCodeBlockCommand, emphasisKeymap, headingKeymap, inlineCodeKeymap, inlineCodeSchema, linkSchema, listItemKeymap, orderedListKeymap, paragraphKeymap, strongKeymap, toggleEmphasisCommand, toggleInlineCodeCommand, toggleLinkCommand, toggleStrongCommand, turnIntoTextCommand, wrapInBulletListCommand, wrapInHeadingCommand, wrapInOrderedListCommand, } from '@milkdown/kit/preset/commonmark';
-import { strikethroughKeymap, tableKeymap, toggleStrikethroughCommand, } from '@milkdown/kit/preset/gfm';
-import { NodeRange, Fragment, Slice, } from '@milkdown/kit/prose/model';
-import { keydownHandler, keymap } from '@milkdown/kit/prose/keymap';
-import { goToNextCell } from '@milkdown/kit/prose/tables';
-import { liftListItem } from '@milkdown/kit/prose/schema-list';
-import { findWrapping, liftTarget } from '@milkdown/kit/prose/transform';
-import { AllSelection, NodeSelection, Plugin, PluginKey, Selection, TextSelection, } from '@milkdown/kit/prose/state';
-import { $prose, callCommand, replaceAll, } from '@milkdown/kit/utils';
-import { codeCopyPlugin, placeholderPlugin } from './decorations.js';
-import { labelsCtx, defaultLabels } from './labels.js';
-import { createDialect, stringifyOptions } from './dialect.js';
-import { Preservation } from './preserve.js';
-import { sourceAttribute, cleanSourceDoc, editedPlainSource, sourceSelection, rawOffset, normalizedOffset, } from './source.js';
-import { normaliseLabel, referenceDefinitions, footnoteDefinitions, singleLine, } from './references.js';
-import { selectionMarkdown, selectionContent, referenceMetadata, withReferenceMetadata, } from './reference-clipboard.js';
-import { imageView } from './images.js';
-import { imagePlacement, isImage, isImageBlock } from './image-blocks.js';
-import { GapCursor } from '@milkdown/kit/prose/gapcursor';
-import { wikiLinkView } from './wiki-view.js';
-import { withFileSignal } from './files.js';
-import { tablePlugins, tableCommand, tableCommands, tableAvailability, tableContext, configureTableMovement, } from './tables.js';
-import { InkKitError, } from './types.js';
-import { readableProjection, projectionPosition, projectionOffset, validateOffsets, formattedRects, literalRangesRects, literalVisibleRanges, intersectsViewport, textRect, } from './text-ranges.js';
-import { highlightKeymap, toggleHighlightCommand } from './inline-highlight.js';
-import { assertCommentsEndWhereWritten, commentSelectionContent, isWrittenEdit, setCommentVisibility, sourceReplacement, } from './comments.js';
-import { scrollOutward, scrollWholePixels } from './scroll.js';
-import { PasteController } from './paste.js';
-import { selectionPlugin } from './selection.js';
-import { search, SearchQuery, setSearchState } from 'prosemirror-search';
-import { findFormatted, findLiteral, replaceFormatted, replaceLiteral, replaceFormattedRange, } from './search.js';
-import { collectFormattedHeadings, collectSourceHeadings, navigateFormattedHeading, sourceHeadingPosition, } from './outline.js';
-import { taskListPlugin, toggleTaskList } from './tasks.js';
-import { diagramsAvailable, isMermaid, mermaidPreview } from './mermaid.js';
-import { hasAuthoredImagesInLiterals, printableMarkdown, printableText, } from './print.js';
-const shortcutCommands = {
-    heading1: ['heading', 1],
-    heading2: ['heading', 2],
-    heading3: ['heading', 3],
-    heading4: ['heading', 4],
-    heading5: ['heading', 5],
-    heading6: ['heading', 6],
-    paragraph: ['paragraph'],
-    bold: ['bold'],
-    italic: ['italic'],
-    strikethrough: ['strikethrough'],
-    highlight: ['highlight'],
-    code: ['code'],
-    codeBlock: ['codeBlock'],
-    quote: ['quote'],
-    bulletList: ['bulletList'],
-    orderedList: ['orderedList'],
-    taskList: ['taskList'],
-};
-const markNames = {
-    strong: 'bold',
-    emphasis: 'italic',
-    strike_through: 'strikethrough',
-    highlight: 'highlight',
-    inlineCode: 'code',
-    link: 'link',
-};
-// Select All resolves at the document level, where no block can be read.
-function textBounds(state) {
-    const { selection, doc } = state;
-    if (selection instanceof AllSelection)
-        return TextSelection.between(doc.resolve(0), doc.resolve(doc.content.size));
-    return selection;
-}
-function caretState(state) {
-    const { empty } = state.selection;
-    const { $from, $to } = textBounds(state);
-    const active = new Set();
-    const marks = empty ? (state.storedMarks ?? $from.marks()) : [];
-    for (const mark of marks) {
-        const name = markNames[mark.type.name];
-        if (name)
-            active.add(name);
-    }
-    if (!empty) {
-        for (const [name, mark] of Object.entries(markNames)) {
-            const type = state.schema.marks[name];
-            if (type && state.doc.rangeHasMark($from.pos, $to.pos, type))
-                active.add(mark);
-        }
-    }
-    return {
-        marks: [...active],
-        block: blockAt($from.parent, $from),
-        quoted: quoted($from, $to),
-    };
-}
-// True only when one quote holds the whole selection, so the state matches what the command can lift.
-function quoted($from, $to) {
-    return ($from.blockRange($to, (node) => node.type.name === 'blockquote') != null);
-}
-function blockAt(parent, $from) {
-    for (let depth = $from.depth; depth > 0; depth--) {
-        const node = $from.node(depth);
-        switch (node.type.name) {
-            case 'heading':
-                return { type: 'heading', level: node.attrs.level };
-            case 'code_block':
-                return { type: 'codeBlock' };
-            case 'list_item':
-                return node.attrs.checked == null
-                    ? {
-                        type: $from.node(depth - 1).type.name === 'ordered_list'
-                            ? 'orderedList'
-                            : 'bulletList',
-                    }
-                    : { type: 'taskList' };
-        }
-    }
-    if (parent.type.name === 'heading')
-        return { type: 'heading', level: parent.attrs.level };
-    return { type: 'paragraph' };
-}
-// Backspace at the start of a quote's first block is left alone by the preset;
-// leaving the quote is what a Backspace there means.
-const quoteBackspace = $prose(() => keymap({
-    Backspace: (state, dispatch) => {
-        const { $from, empty } = state.selection;
-        if (!empty || $from.parentOffset > 0 || $from.depth < 2)
-            return false;
-        if ($from.node($from.depth - 1).type.name !== 'blockquote' ||
-            $from.index($from.depth - 1) > 0)
-            return false;
-        const range = $from.blockRange($from, (node) => node.type.name === 'blockquote');
-        const target = range && liftTarget(range);
-        if (!range || target == null)
-            return false;
-        dispatch?.(state.tr.lift(range, target).scrollIntoView());
-        return true;
-    },
-}));
-// The preset lifts only an item's first line, which cannot leave on its own while the item holds
-// more, such as a nested list: at the top of a document Backspace did nothing, and below another block
-// it merged the line upward and left an empty bullet. The whole item is lifted instead, and a nested
-// list it held joins the items that followed, since both now sit at one level.
-const listItemBackspace = $prose(() => keymap({
-    Backspace: (state, dispatch) => {
-        const { $from, empty } = state.selection;
-        if (!empty || $from.parentOffset > 0 || $from.depth < 3)
-            return false;
-        const item = $from.node(-1);
-        if (item.type.name !== 'list_item' ||
-            item.childCount < 2 ||
-            $from.index(-1) > 0 ||
-            $from.index(-2) > 0)
-            return false;
-        const { doc } = state;
-        const range = new NodeRange(doc.resolve($from.start(-1)), doc.resolve($from.end(-1)), $from.depth - 1);
-        const target = liftTarget(range);
-        if (target == null)
-            return false;
-        const tr = state.tr.lift(range, target);
-        const $line = tr.doc.resolve(tr.mapping.map($from.pos));
-        joinLists(tr, $line.start(-1), $line.index(-1) + item.childCount);
-        dispatch?.(tr.scrollIntoView());
-        return true;
-    },
-}));
-// Lifting an item out of a list that no item holds, the preset leaves a nested list the item held
-// beside the items that followed. Out of a nested list it joins the two itself.
-const liftItem = (state, dispatch) => {
-    const itemType = state.schema.nodes.list_item;
-    const { $from, $to } = state.selection;
-    const range = $from.blockRange($to, (node) => node.firstChild?.type === itemType);
-    const lift = liftListItem(itemType);
-    if (!range || !dispatch || $from.node(range.depth - 1).type === itemType)
-        return lift(state, dispatch);
-    let lifted;
-    if (!lift(state, (tr) => (lifted = tr)) || !lifted)
-        return false;
-    let count = 0;
-    for (let index = range.startIndex; index < range.endIndex; index++)
-        count += range.parent.child(index).childCount;
-    const start = range.$from.start(range.depth - 1);
-    const first = range.$from.index(range.depth - 1) + (range.startIndex > 0 ? 1 : 0);
-    joinLists(lifted, start, first + count);
-    joinLists(lifted, start, first);
-    dispatch(lifted);
-    return true;
-};
-const listItemShiftTab = $prose(() => keymap({ 'Shift-Tab': liftItem }));
-// A control chord that nothing handles reaches the page as its ASCII control character
-// (Control-N as U+000E), which the web view would insert as text.
-const controlCharacters = /^[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]+$/;
-const dropControlCharacters = $prose(() => new Plugin({
-    key: new PluginKey('dropControlCharacters'),
-    props: {
-        handleTextInput: (_view, _from, _to, text) => controlCharacters.test(text),
-    },
-}));
-// The listener plugin reports selection changes from inside state.apply, before
-// the view holds the new state, so the caret state is read from the view instead.
-function caretStatePlugin(events, active = () => true) {
-    return $prose(() => new Plugin({
-        key: new PluginKey('caretState'),
-        view: () => ({
-            update(view, previous) {
-                if (!active())
-                    return;
-                const { state } = view;
-                if (state.selection.eq(previous.selection) &&
-                    state.doc.eq(previous.doc) &&
-                    state.storedMarks === previous.storedMarks)
-                    return;
-                events.stateChanged(caretState(state));
-            },
-        }),
-    }));
-}
-function outermostListDepth($pos) {
-    for (let depth = 1; depth <= $pos.depth; depth++) {
-        if (isList($pos.node(depth)))
-            return depth;
-    }
-    return null;
-}
-function innermostListDepth($pos) {
-    for (let depth = $pos.depth; depth >= 1; depth--) {
-        if (isList($pos.node(depth)))
-            return depth;
-    }
-    return null;
-}
-function isList(node) {
-    return node.type.name === 'bullet_list' || node.type.name === 'ordered_list';
-}
-// Two lists of one kind side by side are written with a changed marker to keep them apart, and the
-// document shows a gap between them, so an edit that leaves them so joins them.
-function joinLists(tr, start, index) {
-    const $start = tr.doc.resolve(start);
-    const before = $start.parent.maybeChild(index - 1);
-    const after = $start.parent.maybeChild(index);
-    if (before && after && isList(before) && after.type === before.type)
-        tr.join($start.posAtIndex(index));
-}
-let editorSequence = 0;
-// A pause in source typing longer than this ends an undo step, as in the
-// formatted editor's history.
-const sourceGroupDelay = 500;
-// Earlier undo steps of typed source that the formatted document has not taken
-// in; the oldest merge into the next beyond this many.
-const sourceStepLimit = 100;
-export class InkKitEditor {
-    events;
-    options;
-    editor;
-    lastMarkdown = '';
-    documentId = '';
-    formatType = 'md';
-    revision = 0;
-    documentEpoch = 0;
-    operationSequence = 0;
-    exportControllers = new Set();
-    plainComposing = false;
-    plainSearch = '';
-    literalMatch;
-    beforePlainInput;
-    // Source typed in the source editor that the hidden formatted document has
-    // not taken in yet. The text is already authoritative: snapshots, change
-    // events and the textarea use it, and anything that reads the formatted
-    // document first settles it. Undo steps taken inside it need no document,
-    // so they run on the text alone: `typedSteps` hold the states at the end of
-    // earlier typing, `pendingSource` the latest, and `undoneSteps` what undo
-    // set aside.
-    pendingSource;
-    typedSteps = [];
-    undoneSteps = [];
-    // Formatted-history undos taken while source steps were undone, which a
-    // redo replays before it reaches those steps.
-    formattedUndone = 0;
-    lastSourceInput = 0;
-    syncingSource = false;
-    mode = 'formatted';
-    sourcePreservations = new WeakMap();
-    sourceTexts = new WeakMap();
-    outlineEpoch = 0;
-    ready = false;
-    destroyed = false;
-    preservation;
-    pasteController;
-    plain;
-    root;
-    ownsRootClass = false;
-    clickHandler;
-    footnoteKeyHandler;
-    copyHandler;
-    originalSource = '';
-    generation = 0;
-    reportingSuppressed = false;
-    loading = false;
-    textIdentity = ++editorSequence;
-    textScope;
-    viewportContainer;
-    viewportInsets = {
-        top: 0,
-        right: 0,
-        bottom: 0,
-        left: 0,
-    };
-    writable = true;
-    inputPreferences = {};
-    policyEpoch = 0;
-    literalKeys = () => false;
-    configuredKeys = {};
-    readOnlyKeys = () => false;
-    changePlugin = $prose(() => new Plugin({
-        key: new PluginKey('documentChanges'),
-        view: () => ({
-            update: (view, previous) => {
-                if (this.loading || view.state.doc.eq(previous.doc))
-                    return;
-                // Settling typed source brings the document up to a revision and a
-                // change event that were already reported.
-                if (this.syncingSource) {
-                    this.mediaPolicy();
-                    return;
-                }
-                this.revision += 1;
-                this.cancelExports();
-                this.mediaPolicy();
-                this.literalMatch = undefined;
-                let markdown;
-                try {
-                    markdown = this.currentText(view.state.doc);
-                }
-                catch (error) {
-                    this.events.error?.(error instanceof Error ? error : new Error(String(error)));
-                    return;
-                }
-                if (this.literalSurface) {
-                    const anchor = view.state.doc.attrs[sourceAttribute];
-                    const from = anchor?.from ?? this.plain.selectionStart;
-                    const to = anchor?.to ?? this.plain.selectionEnd;
-                    if (!this.plainComposing)
-                        this.plain.value = markdown;
-                    if (!this.plainComposing) {
-                        this.plain.setSelectionRange(Math.min(from, this.plain.value.length), Math.min(to, this.plain.value.length));
-                        this.revealLiteralSelection();
-                    }
-                }
-                if (markdown === this.lastMarkdown)
-                    return;
-                this.lastMarkdown = markdown;
-                this.events.changed(markdown, this.generation);
-            },
-        }),
-    }));
-    keys = () => false;
-    constructor(events, options) {
-        this.events = events;
-        this.options = options;
-        this.writable = options.editable ?? true;
-        this.inputPreferences = { ...options.textInput };
-    }
-    context() {
-        return {
-            documentId: this.documentId,
-            generation: this.generation,
-            operationId: `${this.documentEpoch}:${this.generation}:${++this.operationSequence}`,
-        };
-    }
-    cancelExports() {
-        for (const controller of this.exportControllers)
-            controller.abort();
-        this.exportControllers.clear();
-    }
-    async exportContent(snapshot, operation) {
-        const epoch = this.documentEpoch;
-        const mode = this.editingMode;
-        const controller = new AbortController();
-        this.exportControllers.add(controller);
-        try {
-            return await withFileSignal(operation(controller.signal), controller.signal);
-        }
-        finally {
-            this.exportControllers.delete(controller);
-            this.assertCurrent(snapshot.generation);
-            if (controller.signal.aborted ||
-                epoch !== this.documentEpoch ||
-                snapshot.documentId !== this.documentId ||
-                snapshot.revision !== this.revision ||
-                mode !== this.editingMode)
-                throw new InkKitError('stale-document', 'Document changed while preparing output');
-        }
-    }
-    mediaPolicy() {
-        if (this.editor && this.root)
-            this.editor.ctx
-                .get(editorViewCtx)
-                .dom.dispatchEvent(new Event('inkkit-media-policy'));
-    }
-    assertAlive() {
-        if (this.destroyed)
-            throw new InkKitError('destroyed', 'The editor has been destroyed');
-    }
-    assertCurrent(generation = this.generation) {
-        this.assertAlive();
-        if (!this.ready)
-            throw new InkKitError('not-ready', 'No document has been loaded');
-        if (generation !== this.generation)
-            throw new InkKitError('stale-document', 'Document changed');
-        if (this.literalSurface
-            ? this.plainComposing
-            : this.editor.ctx.get(editorViewCtx).composing)
-            throw new InkKitError('composition', 'Text composition is in progress');
-        if (this.pasteController.pending)
-            throw new InkKitError('operation-pending', 'An image import is in progress');
-    }
-    assertMutation(generation = this.generation) {
-        this.assertCurrent(generation);
-        if (!this.writable)
-            throw new InkKitError('read-only', 'The editor is read-only');
-    }
-    get composing() {
-        return this.literalSurface
-            ? this.plainComposing
-            : this.editor.ctx.get(editorViewCtx).composing;
-    }
-    get editable() {
-        this.assertAlive();
-        return this.writable;
-    }
-    setEditable(editable) {
-        this.assertAlive();
-        if (this.composing)
-            throw new InkKitError('composition', 'Text composition is in progress');
-        if (this.writable === editable)
-            return;
-        const suppressed = this.reportingSuppressed;
-        this.reportingSuppressed = true;
-        try {
-            this.writable = editable;
-            this.policyEpoch += 1;
-            if (!editable)
-                this.pasteController.cancelPending();
-            this.editor.ctx
-                .get(editorViewCtx)
-                .dom.dispatchEvent(new Event('inkkit-cancel-resize'));
-            this.applyInputPolicy();
-            this.mediaPolicy();
-        }
-        finally {
-            this.reportingSuppressed = suppressed;
-        }
-        this.publishCommandState();
-    }
-    setTextInputPreferences(preferences) {
-        this.assertAlive();
-        if (this.composing)
-            throw new InkKitError('composition', 'Text composition is in progress');
-        const suppressed = this.reportingSuppressed;
-        this.reportingSuppressed = true;
-        try {
-            this.inputPreferences = { ...preferences };
-            this.applyInputPolicy();
-        }
-        finally {
-            this.reportingSuppressed = suppressed;
-        }
-        this.publishCommandState();
-    }
-    applyInputPolicy() {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const attributes = typeof view.props.attributes === 'function'
-            ? view.props.attributes(view.state)
-            : view.props.attributes;
-        view.setProps({
-            editable: () => this.writable && !this.literalSurface,
-            attributes: {
-                ...attributes,
-                role: 'textbox',
-                'aria-multiline': 'true',
-                'aria-label': this.options.labels?.formattedEditor ?? defaultLabels.formattedEditor,
-            },
-        });
-        this.plain.readOnly = !this.writable;
-        for (const surface of [view.dom, this.plain]) {
-            for (const name of [
-                'spellcheck',
-                'autocorrect',
-                'autocapitalize',
-            ]) {
-                const value = this.inputPreferences[name];
-                if (value == null)
-                    surface.removeAttribute(name);
-                else
-                    surface.setAttribute(name, name === 'autocorrect' ? (value ? 'on' : 'off') : String(value));
-            }
-        }
-    }
-    publishCommandState() {
-        if (!this.ready ||
-            this.loading ||
-            this.reportingSuppressed ||
-            this.destroyed)
-            return;
-        this.events.commandStateChanged?.(this.commandState());
-    }
-    commandState(expectedGeneration = this.generation) {
-        this.assertAlive();
-        if (!this.ready)
-            throw new InkKitError('not-ready', 'No document has been loaded');
-        if (expectedGeneration !== this.generation)
-            throw new InkKitError('stale-document', 'Document changed');
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { state } = view;
-        const mutable = this.writable && !this.composing && !this.pasteController.pending;
-        const formatted = mutable && !this.literalSurface;
-        const manager = this.editor.ctx.get(commandsCtx);
-        const check = (key, payload) => formatted && manager.get(key)(payload)(state);
-        const format = {
-            heading: check(wrapInHeadingCommand.key, 1) || check(turnIntoTextCommand.key),
-            paragraph: check(turnIntoTextCommand.key),
-            bold: check(toggleStrongCommand.key),
-            italic: check(toggleEmphasisCommand.key),
-            strikethrough: check(toggleStrikethroughCommand.key),
-            highlight: check(toggleHighlightCommand.key),
-            code: formatted &&
-                (state.selection.empty
-                    ? state.selection.$from.parent.inlineContent &&
-                        state.selection.$from.parent.type.allowsMarkType(inlineCodeSchema.type(this.editor.ctx))
-                    : check(toggleInlineCodeCommand.key)),
-            codeBlock: check(createCodeBlockCommand.key, '') || check(turnIntoTextCommand.key),
-            quote: formatted && this.canQuote(state),
-            bulletList: formatted &&
-                (innermostListDepth(textBounds(state).$from) != null ||
-                    check(wrapInBulletListCommand.key)),
-            orderedList: formatted &&
-                (innermostListDepth(textBounds(state).$from) != null ||
-                    check(wrapInOrderedListCommand.key)),
-            taskList: formatted &&
-                (innermostListDepth(textBounds(state).$from) != null ||
-                    check(wrapInBulletListCommand.key)),
-            link: check(toggleLinkCommand.key, {}),
-        };
-        const tables = formatted
-            ? tableAvailability(this.editor.ctx)
-            : Object.fromEntries(tableCommands.map((name) => [name, false]));
-        return {
-            documentId: this.documentId,
-            generation: this.generation,
-            revision: this.revision,
-            format: this.formatType,
-            mode: this.editingMode,
-            editable: this.writable,
-            composing: this.composing,
-            pending: this.pasteController.pending,
-            caret: this.literalSurface
-                ? { marks: [], block: { type: 'paragraph' }, quoted: false }
-                : caretState(state),
-            table: this.literalSurface ? undefined : tableContext(state),
-            commands: {
-                undo: mutable && (!!this.pendingSource || undoHistory(state)),
-                redo: mutable &&
-                    (this.undoneSteps.length > 0 ||
-                        (!this.pendingSource && redoHistory(state))),
-                insertText: mutable,
-                paste: mutable,
-                replace: mutable,
-                replaceSource: mutable,
-                insertImages: formatted && !!this.options.images,
-                insertPaths: mutable,
-                insertFootnote: formatted,
-                editReferenceDefinition: formatted && referenceDefinitions(state.doc).size > 0,
-                format,
-                table: tables,
-            },
-        };
-    }
-    canQuote(state) {
-        const { $from, $to } = textBounds(state);
-        if (quoted($from, $to)) {
-            const range = $from.blockRange($to, (node) => node.type.name === 'blockquote');
-            return !!range && liftTarget(range) != null;
-        }
-        const type = blockquoteSchema.type(this.editor.ctx);
-        let range = $from.blockRange($to);
-        if (range && findWrapping(range, type))
-            return true;
-        const depth = outermostListDepth($from);
-        if (depth == null)
-            return false;
-        range = new NodeRange(state.doc.resolve($from.before(depth)), state.doc.resolve($from.after(depth)), depth - 1);
-        return !!findWrapping(range, type);
-    }
-    policyPlugin = $prose(() => new Plugin({
-        key: new PluginKey('inkkitInputPolicy'),
-        filterTransaction: (tr) => this.loading ||
-            this.writable ||
-            // Source that was typed while the editor was writable.
-            this.syncingSource ||
-            (!tr.docChanged && !tr.storedMarksSet),
-        props: {
-            editable: () => this.writable && !this.literalSurface,
-            handleDOMEvents: {
-                compositionstart: () => {
-                    queueMicrotask(() => this.publishCommandState());
-                    return false;
-                },
-                compositionend: () => {
-                    queueMicrotask(() => this.publishCommandState());
-                    return false;
-                },
-                beforeinput: (_view, event) => {
-                    if (this.writable)
-                        return false;
-                    event.preventDefault();
-                    return true;
-                },
-                drop: (_view, event) => {
-                    if (this.writable)
-                        return false;
-                    event.preventDefault();
-                    return true;
-                },
-            },
-        },
-        view: () => ({ update: () => this.publishCommandState() }),
-    }));
-    get literalSurface() {
-        return this.formatType === 'txt' || this.mode === 'source';
-    }
-    get editingMode() {
-        this.assertAlive();
-        return this.literalSurface ? 'source' : 'formatted';
-    }
-    currentText(doc) {
-        if (!doc && this.pendingSource)
-            return this.pendingSource.text;
-        doc ??= this.editor.ctx.get(editorViewCtx).state.doc;
-        const cached = this.sourceTexts.get(doc);
-        if (cached !== undefined)
-            return cached;
-        const provenance = doc.attrs[sourceAttribute];
-        if (this.formatType === 'txt')
-            return provenance?.text ?? this.originalSource;
-        let preservation = this.preservation;
-        if (provenance) {
-            preservation = this.sourcePreservations.get(provenance);
-            if (!preservation) {
-                preservation = new Preservation(this.editor.ctx, provenance.text);
-                this.sourcePreservations.set(provenance, preservation);
-            }
-        }
-        const text = preservation.serialize(cleanSourceDoc(doc));
-        this.sourceTexts.set(doc, text);
-        return text;
-    }
-    setEditingMode(mode, expectedGeneration) {
-        this.assertCurrent(expectedGeneration);
-        if (mode !== 'source' && mode !== 'formatted')
-            throw new RangeError('Editing mode must be source or formatted');
-        if (this.formatType === 'txt' || this.mode === mode)
-            return false;
-        this.settleSource();
-        // Source steps that were undone cannot be redone from the other mode.
-        this.undoneSteps = [];
-        this.formattedUndone = 0;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const focused = this.literalSurface
-            ? this.plain.ownerDocument.activeElement === this.plain
-            : view.hasFocus();
-        const container = this.viewportContainer ?? this.root;
-        const top = container.scrollTop, left = container.scrollLeft;
-        const text = this.snapshot().text;
-        this.mode = mode;
-        this.cancelExports();
-        this.outlineEpoch += 1;
-        this.plainSearch = '';
-        this.literalMatch = undefined;
-        if (mode === 'source') {
-            this.plain.value = text;
-            this.plain.setSelectionRange(this.plain.value.length, this.plain.value.length);
-        }
-        const suppressed = this.reportingSuppressed;
-        this.reportingSuppressed = true;
-        try {
-            this.updateSurface();
-        }
-        finally {
-            this.reportingSuppressed = suppressed;
-        }
-        if (focused) {
-            if (this.literalSurface)
-                this.plain.focus({ preventScroll: true });
-            else
-                view.focus();
-        }
-        container.scrollTop = top;
-        container.scrollLeft = left;
-        this.events.stateChanged(this.literalSurface
-            ? { marks: [], block: { type: 'paragraph' }, quoted: false }
-            : caretState(this.editor.ctx.get(editorViewCtx).state));
-        this.publishCommandState();
-        return true;
-    }
-    updateSurface() {
-        this.plain.hidden = !this.literalSurface;
-        this.applyInputPolicy();
-        this.plain.setAttribute('aria-label', this.formatType === 'txt'
-            ? (this.options.labels?.plainTextEditor ??
-                defaultLabels.plainTextEditor)
-            : (this.options.labels?.sourceEditor ?? defaultLabels.sourceEditor));
-        this.editor.ctx.get(editorViewCtx).dom.parentElement.hidden =
-            this.literalSurface;
-        this.mediaPolicy();
-    }
-    replaceSource(text, expectedGeneration) {
-        this.assertMutation(expectedGeneration);
-        return this.applySource(text, true);
-    }
-    applySource(text, isolated, from, to, native = false) {
-        if (!this.writable)
-            throw new InkKitError('read-only', 'The editor is read-only');
-        if (typeof text !== 'string')
-            throw new TypeError('Source must be a string');
-        // Source edits take the same steps whether typed or not; an edit that is
-        // not typing ends the typing step before it and is closed to the next.
-        if (this.literalSurface)
-            return this.deferSource(text, from, to, native, isolated);
-        return this.commitSource(text, isolated, from, to, this.beforePlainInput);
-    }
-    /**
-     * Takes typed source without parsing it. Parsing, preservation and replacing
-     * the formatted document cost as much as a document load, so they wait for
-     * the next thing that needs them.
-     */
-    deferSource(text, from, to, native, closed) {
-        if (text === this.currentText())
-            return false;
-        const length = from === undefined ? text.replace(/\r\n?/g, '\n').length : from;
-        const now = Date.now();
-        const previous = this.pendingSource;
-        const continuing = previous &&
-            !previous.closed &&
-            !closed &&
-            now - this.lastSourceInput <= sourceGroupDelay;
-        if (previous && !continuing)
-            this.rememberTypedStep(previous);
-        this.lastSourceInput = now;
-        this.undoneSteps = [];
-        this.formattedUndone = 0;
-        const pending = {
-            text,
-            from: length,
-            to: to ?? length,
-            before: (continuing ? previous.before : undefined) ??
-                this.beforePlainInput ?? {
-                from: this.plain.selectionStart,
-                to: this.plain.selectionEnd,
-            },
-            closed,
-        };
-        this.pendingSource = pending;
-        this.revision += 1;
-        this.cancelExports();
-        this.literalMatch = undefined;
-        // Text that did not come from the textarea is shown there.
-        if (!native)
-            this.showTypedSource(pending.text, pending.from, pending.to);
-        if (text !== this.lastMarkdown) {
-            this.lastMarkdown = text;
-            this.events.changed(text, this.generation);
-        }
-        this.publishCommandState();
-        return true;
-    }
-    rememberTypedStep(step) {
-        this.typedSteps.push(step);
-        if (this.typedSteps.length > sourceStepLimit)
-            this.typedSteps.shift();
-    }
-    showTypedSource(text, from, to) {
-        this.plain.value = text;
-        this.plain.setSelectionRange(Math.min(from, this.plain.value.length), Math.min(to, this.plain.value.length));
-        this.revealLiteralSelection();
-    }
-    /**
-     * Undoes or redoes typed source that the formatted document has not taken
-     * in, on the text alone. Returns whether there was a step to take.
-     */
-    stepTypedSource(direction) {
-        const current = this.pendingSource;
-        let text, from, to;
-        if (direction === 'undo') {
-            if (!current)
-                return false;
-            this.undoneSteps.push(current);
-            this.pendingSource = this.typedSteps.pop();
-            text = this.pendingSource?.text ?? this.currentText();
-            ({ from, to } = current.before);
-        }
-        else {
-            const next = this.undoneSteps.pop();
-            if (!next)
-                return false;
-            if (current)
-                this.rememberTypedStep(current);
-            this.pendingSource = next;
-            text = next.text;
-            ({ from, to } = next);
-        }
-        this.lastSourceInput = 0;
-        this.revision += 1;
-        this.cancelExports();
-        this.literalMatch = undefined;
-        this.showTypedSource(text, from, to);
-        if (text !== this.lastMarkdown) {
-            this.lastMarkdown = text;
-            this.events.changed(text, this.generation);
-        }
-        this.publishCommandState();
-        return true;
-    }
-    /** Brings the formatted document up to the source that was typed. */
-    settleSource() {
-        const pending = this.pendingSource;
-        if (!pending)
-            return;
-        const steps = this.typedSteps, undone = this.undoneSteps;
-        this.pendingSource = undefined;
-        this.typedSteps = [];
-        this.undoneSteps = [];
-        this.syncingSource = true;
-        try {
-            if (this.commitSource(pending.text, 
-            // A step of its own, whatever edit follows within the group delay.
-            true, pending.from, pending.to, steps[0]?.before ?? pending.before)) {
-                const { doc } = this.editor.ctx.get(editorViewCtx).state;
-                const applied = doc.attrs[sourceAttribute];
-                // A plugin that refuses the change must not lose what was typed.
-                if (applied?.text !== pending.text)
-                    throw new InkKitError('preservation', 'The typed source could not be applied');
-                this.sourceTexts.set(doc, pending.text);
-            }
-        }
-        catch (error) {
-            this.pendingSource = pending;
-            this.typedSteps = steps;
-            this.undoneSteps = undone;
-            throw error;
-        }
-        finally {
-            this.syncingSource = false;
-        }
-    }
-    commitSource(text, isolated, from, to, before) {
-        if (text === this.currentText())
-            return false;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const normalizedLength = text.replace(/\r\n?/g, '\n').length;
-        const provenance = Object.freeze({
-            text,
-            format: this.formatType,
-            from: from ?? normalizedLength,
-            to: to ?? from ?? normalizedLength,
-        });
-        let parsed;
-        try {
-            parsed =
-                this.formatType === 'txt'
-                    ? view.state.schema.topNodeType.create(null, view.state.schema.nodes.paragraph.create(null, text ? view.state.schema.text(text) : undefined))
-                    : this.editor.ctx.get(parserCtx)(text);
-            if (this.formatType === 'md')
-                this.sourcePreservations.set(provenance, new Preservation(this.editor.ctx, text));
-        }
-        catch (error) {
-            throw new InkKitError('preservation', error instanceof Error ? error.message : 'Cannot read Markdown source');
-        }
-        if (this.literalSurface) {
-            const previous = Object.freeze({
-                text: this.currentText(),
-                format: this.formatType,
-                from: before?.from ?? this.plain.selectionStart,
-                to: before?.to ?? this.plain.selectionEnd,
-            });
-            // History must retain the source caret even when the formatted document has no corresponding position.
-            this.loading = true;
-            try {
-                view.dispatch(view.state.tr
-                    .setDocAttribute(sourceAttribute, previous)
-                    .setMeta('addToHistory', false));
-            }
-            finally {
-                this.loading = false;
-            }
-        }
-        let tr = view.state.tr
-            .replaceWith(0, view.state.doc.content.size, parsed.content)
-            .setDocAttribute(sourceAttribute, provenance)
-            .setMeta(sourceReplacement, true);
-        tr.setSelection(Selection.atEnd(tr.doc));
-        if (isolated)
-            tr = closeHistory(tr);
-        view.dispatch(tr);
-        if (isolated)
-            view.dispatch(closeHistory(view.state.tr).setMeta('addToHistory', false));
-        return true;
-    }
-    undo(expectedGeneration) {
-        this.assertMutation(expectedGeneration);
-        if (this.literalSurface && this.stepTypedSource('undo'))
-            return true;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const undone = undoHistory(view.state, view.dispatch);
-        if (undone) {
-            // Source steps that were undone come back after the formatted ones.
-            if (this.literalSurface && this.undoneSteps.length)
-                this.formattedUndone++;
-            else
-                this.undoneSteps = [];
-        }
-        return undone;
-    }
-    redo(expectedGeneration) {
-        this.assertMutation(expectedGeneration);
-        const view = this.editor.ctx.get(editorViewCtx);
-        if (this.literalSurface) {
-            if (this.formattedUndone > 0) {
-                this.formattedUndone--;
-                if (redoHistory(view.state, view.dispatch))
-                    return true;
-                this.formattedUndone = 0;
-            }
-            if (this.stepTypedSource('redo'))
-                return true;
-            // Typing after an undo ended the formatted history's redo steps.
-            if (this.pendingSource)
-                return false;
-        }
-        return redoHistory(view.state, view.dispatch);
-    }
-    replaceLiteralSelection(text, isolated = true, retainEndings = false) {
-        const value = this.plain.value;
-        const start = this.plain.selectionStart, end = this.plain.selectionEnd;
-        const next = value.slice(0, start) + text.replace(/\r\n?/g, '\n') + value.slice(end);
-        const caret = start + text.replace(/\r\n?/g, '\n').length;
-        const previous = this.currentText();
-        const source = retainEndings
-            ? previous.slice(0, rawOffset(previous, start)) +
-                text +
-                previous.slice(rawOffset(previous, end))
-            : editedPlainSource(previous, next);
-        this.applySource(source, isolated, caret, caret);
-    }
-    snapshot(expectedGeneration) {
-        this.assertCurrent(expectedGeneration);
-        let text;
-        try {
-            text = this.currentText();
-        }
-        catch (error) {
-            throw new InkKitError('preservation', error instanceof Error ? error.message : 'Cannot preserve Markdown');
-        }
-        return {
-            documentId: this.documentId,
-            generation: this.generation,
-            revision: this.revision,
-            format: this.formatType,
-            text,
-            dirty: text !== this.originalSource,
-        };
-    }
-    async printableSnapshot(expectedGeneration) {
-        const snapshot = this.snapshot(expectedGeneration);
-        const state = this.editor.ctx.get(editorViewCtx).state;
-        const doc = this.exportDocument(snapshot.text);
-        const output = await this.exportContent(snapshot, async (signal) => {
-            if (snapshot.format === 'md' &&
-                !this.options.images &&
-                !this.options.files &&
-                hasAuthoredImagesInLiterals(doc.content, (source) => this.editor.ctx.get(remarkCtx).parse(source)))
-                throw new InkKitError('image-unavailable', 'No image adapter is configured for the authored images.');
-            return snapshot.format === 'txt'
-                ? printableText(snapshot.text)
-                : printableMarkdown(doc.content, state.schema, this.options.images, this.context(), this.options.files, signal);
-        });
-        return Object.freeze({
-            documentId: snapshot.documentId,
-            generation: snapshot.generation,
-            revision: snapshot.revision,
-            format: snapshot.format,
-            html: output.html,
-            styles: output.styles,
-            assets: Object.freeze(output.assets.map((asset) => Object.freeze({
-                ...asset,
-                bytes: new Uint8Array(asset.bytes),
-            }))),
-            warnings: Object.freeze(output.warnings.map((warning) => Object.freeze({ ...warning }))),
-        });
-    }
-    /**
-     * The document to export. Source typed in the source editor has not reached
-     * the formatted document, which would merge its undo steps, so a document
-     * read from the text stands in without touching history.
-     */
-    exportDocument(text) {
-        const { doc } = this.editor.ctx.get(editorViewCtx).state;
-        return this.pendingSource && this.formatType === 'md'
-            ? this.editor.ctx.get(parserCtx)(text)
-            : doc;
-    }
-    async clipboardSnapshot(all = true) {
-        const snapshot = this.snapshot();
-        const epoch = this.documentEpoch;
-        if (this.formatType === 'txt') {
-            const text = all
-                ? snapshot.text
-                : snapshot.text.slice(rawOffset(snapshot.text, this.plain.selectionStart), rawOffset(snapshot.text, this.plain.selectionEnd));
-            const pre = document.createElement('pre');
-            pre.textContent = text;
-            return {
-                text,
-                html: pre.outerHTML,
-                markdown: text,
-                images: [],
-                diagrams: [],
-            };
-        }
-        const { schema, selection } = this.editor.ctx.get(editorViewCtx).state;
-        // A partial copy in the source editor reads only the selected source.
-        const doc = all || this.mode !== 'source'
-            ? this.exportDocument(snapshot.text)
-            : this.editor.ctx.get(editorViewCtx).state.doc;
-        const selectedSource = !all && this.mode === 'source'
-            ? sourceSelection(snapshot.text, this.plain.selectionStart, this.plain.selectionEnd)
-            : undefined;
-        const selectedDoc = selectedSource
-            ? this.editor.ctx.get(parserCtx)(selectedSource.shareable)
-            : undefined;
-        const completeDiagrams = new Set();
-        (selectedDoc ?? doc).descendants((node, pos) => {
-            if (isMermaid(node) &&
-                (selectedDoc
-                    ? Boolean(node.attrs.authoredFence?.close)
-                    : all ||
-                        (selection.from <= pos + 1 &&
-                            selection.to >= pos + node.nodeSize - 1))) {
-                completeDiagrams.add(node.textContent.replace(/\r\n?/g, '\n'));
-            }
-        });
-        const content = selectedDoc
-            ? selectedDoc.content
-            : all
-                ? doc.content
-                : commentSelectionContent(doc, selection.from, selection.to, selection.content().content);
-        const valid = content.firstChild?.isInline
-            ? Fragment.from(schema.nodes.paragraph.create(null, content))
-            : content;
-        let markdown;
-        try {
-            markdown = selectedSource
-                ? selectedSource.markdown
-                : all
-                    ? snapshot.text
-                    : completeDiagrams.size
-                        ? new Preservation(this.editor.ctx, snapshot.text).serialize(doc.type.create(null, selectionContent(doc, valid)))
-                        : selectionMarkdown(this.editor.ctx, doc, valid);
-        }
-        catch (error) {
-            throw new InkKitError('preservation', error instanceof Error
-                ? error.message
-                : 'Cannot copy the selected Markdown');
-        }
-        const result = await this.exportContent(snapshot, (signal) => portableClipboard(all || selectedDoc ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context(), completeDiagrams, this.options.files, signal));
-        const metadata = referenceMetadata(this.editor.ctx, selectedDoc ?? doc, content);
-        if (metadata != null)
-            result.html = withReferenceMetadata(result.html, metadata);
-        this.assertCurrent(snapshot.generation);
-        if (snapshot.documentId !== this.documentId ||
-            epoch !== this.documentEpoch ||
-            snapshot.revision !== this.revision)
-            throw new InkKitError('stale-document', 'Document changed');
-        if (result.images.some((image) => image.error))
-            this.events.error?.(new InkKitError('image-unavailable', 'Some copied images were unavailable; their descriptions were retained'));
-        // A host built without Mermaid chose not to render diagrams.
-        if (diagramsAvailable() &&
-            result.diagrams?.some((diagram) => diagram.error))
-            this.events.error?.(new InkKitError('diagram-unavailable', 'Some diagrams could not be exported; their source was retained'));
-        return result;
-    }
-    async paste(input) {
-        this.assertMutation();
-        if (this.literalSurface || input.plainText) {
-            this.pasteAsPlainText(this.mode === 'source' && this.formatType === 'md'
-                ? (input.markdown ?? input.text)
-                : input.text);
-            return;
-        }
-        await this.pasteController.paste(input);
-    }
-    setCommentsVisible(visible) {
-        this.assertAlive();
-        setCommentVisibility(this.editor.ctx.get(editorViewCtx), visible);
-    }
-    pasteAsPlainText(text) {
-        this.assertMutation();
-        if (this.literalSurface) {
-            this.replaceLiteralSelection(text, true, this.formatType === 'md');
-        }
-        else {
-            const view = this.editor.ctx.get(editorViewCtx);
-            if (view.state.selection.$from.parent.type.spec.code) {
-                view.dispatch(view.state.tr
-                    .insertText(text.replace(/\r\n?/g, '\n'))
-                    .scrollIntoView());
-            }
-            else {
-                const { schema } = view.state;
-                const marks = view.state.storedMarks ??
-                    (view.state.selection.empty
-                        ? view.state.selection.$from.marks()
-                        : view.state.selection.$from.marksAcross(view.state.selection.$to)) ??
-                    [];
-                const children = [];
-                const lines = text.replace(/\r\n?/g, '\n').split('\n');
-                lines.forEach((line, index) => {
-                    const finalBreak = index === lines.length - 1 && line === '';
-                    if (index)
-                        children.push(schema.nodes.hardbreak.create({
-                            isHTML: finalBreak,
-                        }, null, 
-                        // A terminal HTML spacer must remain outside emphasis to reopen as a break.
-                        finalBreak ? [] : marks));
-                    if (line)
-                        children.push(schema.text(line, marks));
-                });
-                if (!children.length) {
-                    view.dispatch(view.state.tr.deleteSelection());
-                    return;
-                }
-                const paragraph = schema.nodes.paragraph.create(null, children);
-                const transaction = view.state.tr
-                    .replaceSelection(new Slice(Fragment.from(paragraph), 1, 1))
-                    .scrollIntoView();
-                try {
-                    this.currentText(transaction.doc);
-                }
-                catch (error) {
-                    throw new InkKitError('preservation', error instanceof Error
-                        ? error.message
-                        : 'Cannot preserve inserted text');
-                }
-                view.dispatch(transaction);
-            }
-        }
-    }
-    table(command, options) {
-        this.assertMutation();
-        if (this.literalSurface)
-            return false;
-        return tableCommand(this.editor.ctx, command, options);
-    }
-    async destroy() {
-        if (this.destroyed)
-            return;
-        this.destroyed = true;
-        this.ready = false;
-        this.pendingSource = undefined;
-        this.typedSteps = [];
-        this.undoneSteps = [];
-        this.formattedUndone = 0;
-        this.cancelExports();
-        this.mediaPolicy();
-        this.pasteController.destroy();
-        if (this.clickHandler)
-            this.root.removeEventListener('click', this.clickHandler);
-        if (this.footnoteKeyHandler)
-            this.root.removeEventListener('keydown', this.footnoteKeyHandler, true);
-        if (this.copyHandler) {
-            this.root.removeEventListener('copy', this.copyHandler, true);
-            this.root.removeEventListener('cut', this.copyHandler, true);
-        }
-        this.plain.remove();
-        await this.editor.destroy();
-        if (this.ownsRootClass)
-            this.root.classList.remove('inkkit-root');
-    }
-    // The app's bindings, replaced whole whenever they change; the plugin stays.
-    keymapPlugin = $prose(() => new Plugin({
-        key: new PluginKey('appKeymap'),
-        props: {
-            handleKeyDown: (view, event) => {
-                if (event.altKey && event.key === 'Enter') {
-                    return this.navigateFootnote(event.shiftKey ? 'reference' : 'definition');
-                }
-                return this.keys(view, event);
-            },
-        },
-    }));
-    copySourceSelection(event) {
-        event.preventDefault();
-        event.stopPropagation();
-        try {
-            const snapshot = this.snapshot();
-            const from = this.plain.selectionStart, to = this.plain.selectionEnd;
-            const selected = sourceSelection(snapshot.text, from, to);
-            const parsed = this.editor.ctx.get(parserCtx)(selected.shareable);
-            let portable = false;
-            parsed.descendants((node) => {
-                if (isImage(node) || isMermaid(node))
-                    portable = true;
-            });
-            const cut = event.type === 'cut' && this.writable;
-            const policyEpoch = this.policyEpoch;
-            const epoch = this.documentEpoch;
-            if (portable && this.events.clipboard) {
-                void this.clipboardSnapshot(false)
-                    .then(async (content) => {
-                    if (cut &&
-                        (content.images.some((image) => image.error) ||
-                            content.diagrams?.some((diagram) => diagram.error)))
-                        throw new InkKitError('image-unavailable', 'The selected content could not be cut safely');
-                    await this.events.clipboard(content);
-                    if (cut) {
-                        this.assertMutation(snapshot.generation);
-                        if (epoch !== this.documentEpoch ||
-                            policyEpoch !== this.policyEpoch ||
-                            snapshot.revision !== this.revision)
-                            throw new InkKitError('stale-document', 'Document changed before cutting');
-                        this.plain.setSelectionRange(from, to);
-                        this.replaceLiteralSelection('');
-                    }
-                })
-                    .catch((error) => this.events.error?.(error));
-            }
-            else {
-                const output = clipboardContent(parsed.content, parsed.type.schema);
-                if (!event.clipboardData)
-                    return;
-                event.clipboardData.setData('text/plain', output.text);
-                event.clipboardData.setData('text/html', output.html);
-                if (portable) {
-                    this.events.error?.(new InkKitError('image-unavailable', 'The host must provide a clipboard handler for portable images and diagrams'));
-                    return;
-                }
-                if (cut)
-                    this.replaceLiteralSelection('');
-            }
-        }
-        catch (error) {
-            this.events.error?.(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    static async mount(root, events, options = {}) {
-        const instance = new InkKitEditor(events, options);
-        instance.root = root;
-        instance.ownsRootClass = !root.classList.contains('inkkit-root');
-        root.classList.add('inkkit-root');
-        instance.pasteController = new PasteController({
-            ctx: () => instance.editor.ctx,
-            context: () => instance.context(),
-            adapter: options.images,
-            onError: (error) => events.error?.(error instanceof Error ? error : new Error(String(error))),
-            literalText: () => instance.literalSurface,
-            editable: () => instance.writable && !instance.literalSurface,
-            onPendingChanged: () => instance.publishCommandState(),
-        });
-        instance.editor = await Editor.make()
-            .config((ctx) => {
-            ctx.set(rootCtx, root);
-            ctx.update(labelsCtx.key, () => ({
-                ...defaultLabels,
-                ...options.labels,
-            }));
-            ctx.set(defaultValueCtx, '');
-            ctx.set(remarkStringifyOptionsCtx, stringifyOptions);
-            // The preset also binds Mod-[ and Mod-] here; the app uses those for back and forward.
-            // Shift-Tab is bound to liftItem instead.
-            ctx.update(listItemKeymap.key, (keys) => ({
-                ...keys,
-                SinkListItem: { shortcuts: 'Tab' },
-                LiftListItem: { shortcuts: [] },
-            }));
-            // Formatting keys are the app's to set, through setKeymap; the presets' own go.
-            const unbind = (keymap, keep = []) => ctx.update(keymap.key, (keys) => {
-                const cleared = { ...keys };
-                for (const name of Object.keys(cleared)) {
-                    if (!keep.includes(name))
-                        cleared[name] = { shortcuts: [] };
-                }
-                return cleared;
-            });
-            unbind(tableKeymap, ['NextCell', 'PrevCell']);
-            unbind(historyKeymap);
-            unbind(strongKeymap);
-            unbind(emphasisKeymap);
-            unbind(inlineCodeKeymap);
-            unbind(strikethroughKeymap);
-            unbind(highlightKeymap);
-            unbind(headingKeymap, ['DowngradeHeading']);
-            unbind(paragraphKeymap);
-            unbind(blockquoteKeymap);
-            unbind(codeBlockKeymap);
-            unbind(bulletListKeymap);
-            unbind(orderedListKeymap);
-            ctx.update(editorViewOptionsCtx, (options) => ({
-                ...options,
-                dispatchTransaction: function (tr) {
-                    const next = this.state.apply(tr);
-                    if (!instance.loading) {
-                        try {
-                            instance.assertPreserved(this.state.doc, next.doc, isWrittenEdit(tr));
-                        }
-                        catch (error) {
-                            this.updateState(this.state);
-                            instance.events.error?.(new InkKitError('preservation', `The edit was not applied because its Markdown could not be preserved: ${error instanceof Error ? error.message : String(error)}`));
-                            return;
-                        }
-                    }
-                    this.updateState(next);
-                },
-                handleScrollToSelection: () => {
-                    if (!instance.loading && instance.ready)
-                        instance.revealCurrentSelection();
-                    return true;
-                },
-            }));
-        })
-            .use(labelsCtx)
-            .use(caretStatePlugin(events, () => !instance.loading && !instance.literalSurface))
-            .use(instance.pasteController.plugin)
-            .use(visibleClipboard)
-            .use(instance.keymapPlugin)
-            .use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files)))
-            .use(tablePlugins)
-            .use(instance.changePlugin)
-            .use(history)
-            .use(clipboard)
-            .use(cursor)
-            .use(taskListPlugin)
-            .use(quoteBackspace)
-            .use(listItemBackspace)
-            .use(listItemShiftTab)
-            .use(dropControlCharacters)
-            .use(codeCopyPlugin((text) => events.copy(text)))
-            .use(placeholderPlugin)
-            .use(options.rendering?.codeHighlighting === false
-            ? []
-            : (await import('./highlight.js')).highlightPlugin)
-            .use(options.rendering?.diagramPreview === false || !diagramsAvailable()
-            ? []
-            : mermaidPreview((error) => events.error?.(error)))
-            .use(selectionPlugin)
-            .use($prose(() => search()))
-            .use(instance.policyPlugin)
-            .use(options.wikiLinks
-            ? wikiLinkView(options.wikiLinks, {
-                capture: () => {
-                    const epoch = instance.documentEpoch;
-                    const context = instance.context();
-                    return {
-                        context,
-                        isCurrent: () => !instance.destroyed &&
-                            epoch === instance.documentEpoch &&
-                            context.documentId === instance.documentId &&
-                            context.generation === instance.generation,
-                    };
-                },
-                active: () => instance.ready &&
-                    !instance.destroyed &&
-                    !instance.literalSurface,
-                labels: { ...defaultLabels, ...options.labels },
-                error: (error) => events.error?.(error),
-            })
-            : [])
-            .use(options.images || options.files
-            ? imageView(options.images, options.files
-                ? {
-                    adapter: options.files,
-                    capture: () => {
-                        const epoch = instance.documentEpoch;
-                        const context = instance.context();
-                        return {
-                            context,
-                            isCurrent: () => !instance.destroyed &&
-                                epoch === instance.documentEpoch &&
-                                context.documentId === instance.documentId &&
-                                context.generation === instance.generation,
-                        };
-                    },
-                    active: () => instance.ready &&
-                        !instance.destroyed &&
-                        !instance.literalSurface,
-                    labels: { ...defaultLabels, ...options.labels },
-                    error: (error) => events.error?.(error),
-                }
-                : undefined, () => {
-                try {
-                    instance.assertMutation();
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            })
-            : [])
-            .create();
-        configureTableMovement(instance.editor.ctx, () => {
-            try {
-                instance.assertCurrent();
-                return instance.writable && !instance.literalSurface;
-            }
-            catch {
-                return false;
-            }
-        });
-        instance.plain = document.createElement('textarea');
-        instance.plain.className = 'inkkit-plain';
-        instance.plain.setAttribute('aria-label', 'Plain text editor');
-        instance.plain.hidden = true;
-        root.append(instance.plain);
-        instance.plain.addEventListener('beforeinput', (event) => {
-            if (!instance.writable) {
-                event.preventDefault();
-                return;
-            }
-            if (instance.ready && instance.literalSurface)
-                instance.beforePlainInput = {
-                    from: instance.plain.selectionStart,
-                    to: instance.plain.selectionEnd,
-                };
-        });
-        instance.plain.addEventListener('input', () => {
-            if (!instance.ready || !instance.literalSurface)
-                return;
-            if (!instance.writable) {
-                instance.plain.value = instance.currentText();
-                return;
-            }
-            try {
-                instance.applySource(editedPlainSource(instance.currentText(), instance.plain.value), false, instance.plain.selectionStart, instance.plain.selectionEnd, true);
-            }
-            catch (error) {
-                events.error?.(error instanceof Error ? error : new Error(String(error)));
-            }
-            finally {
-                instance.beforePlainInput = undefined;
-            }
-        });
-        instance.plain.addEventListener('keydown', (event) => {
-            if (instance.plainComposing)
-                return;
-            if (instance.literalKeys(instance.editor.ctx.get(editorViewCtx), event))
-                event.preventDefault();
-        });
-        for (const event of ['select', 'keyup', 'click'])
-            instance.plain.addEventListener(event, () => instance.publishCommandState());
-        instance.plain.addEventListener('paste', (event) => {
-            if (!instance.writable) {
-                event.preventDefault();
-                return;
-            }
-            if (!event.clipboardData)
-                return;
-            event.preventDefault();
-            void instance
-                .paste({
-                text: event.clipboardData.getData('text/plain'),
-                markdown: event.clipboardData.getData('text/markdown') || undefined,
-            })
-                .catch((error) => events.error?.(error));
-        });
-        instance.plain.addEventListener('compositionstart', () => {
-            instance.plainComposing = true;
-            instance.publishCommandState();
-        });
-        instance.plain.addEventListener('compositionend', () => {
-            instance.plainComposing = false;
-            instance.publishCommandState();
-        });
-        const activateFootnote = (event) => {
-            const element = event.target.closest('[data-inkkit-footnote-reference]');
-            if (!element)
-                return false;
-            const identifier = element.getAttribute('data-inkkit-footnote-reference');
-            const view = instance.editor.ctx.get(editorViewCtx);
-            let position;
-            view.state.doc.descendants((node, pos) => {
-                if (position == null &&
-                    node.type.name === 'footnote_reference' &&
-                    node.attrs.identifier === identifier)
-                    position = pos;
-            });
-            if (position == null)
-                return false;
-            event.preventDefault();
-            try {
-                view.dispatch(view.state.tr.setSelection(NodeSelection.create(view.state.doc, position)));
-                instance.navigateFootnote('definition');
-            }
-            catch (error) {
-                events.error?.(error instanceof Error ? error : new Error(String(error)));
-            }
-            return true;
-        };
-        instance.footnoteKeyHandler = (event) => {
-            if ((event.key === 'Enter' || event.key === ' ') &&
-                activateFootnote(event))
-                event.stopPropagation();
-        };
-        root.addEventListener('keydown', instance.footnoteKeyHandler, true);
-        instance.clickHandler = (event) => {
-            if (activateFootnote(event))
-                return;
-            const anchor = event.target.closest('a[href]');
-            if (anchor && event.metaKey) {
-                event.preventDefault();
-                events.openLink(anchor.getAttribute('href') ?? '');
-            }
-        };
-        root.addEventListener('click', instance.clickHandler);
-        instance.copyHandler = (event) => {
-            if (instance.formatType === 'txt')
-                return;
-            if (instance.mode === 'source') {
-                instance.copySourceSelection(event);
-                return;
-            }
-            const view = instance.editor.ctx.get(editorViewCtx);
-            const fragment = commentSelectionContent(view.state.doc, view.state.selection.from, view.state.selection.to, view.state.selection.content().content);
-            const expanded = selectionContent(view.state.doc, fragment);
-            let hasImages = false;
-            expanded.descendants((node) => {
-                if (isImage(node) || isMermaid(node))
-                    hasImages = true;
-            });
-            if (!hasImages) {
-                if (!event.clipboardData || fragment.size === 0)
-                    return;
-                event.preventDefault();
-                event.stopPropagation();
-                try {
-                    instance.snapshot();
-                    const content = expanded;
-                    const valid = fragment.firstChild?.isInline
-                        ? Fragment.from(view.state.schema.nodes.paragraph.create(null, fragment))
-                        : fragment;
-                    const markdown = selectionMarkdown(instance.editor.ctx, view.state.doc, valid);
-                    const output = clipboardContent(content, view.state.schema);
-                    event.clipboardData.setData('text/plain', output.text);
-                    const metadata = referenceMetadata(instance.editor.ctx, view.state.doc, valid);
-                    event.clipboardData.setData('text/html', metadata != null
-                        ? withReferenceMetadata(output.html, metadata)
-                        : output.html);
-                    if (event.type === 'cut' && instance.writable)
-                        view.dispatch(view.state.tr.deleteSelection().scrollIntoView());
-                }
-                catch (error) {
-                    events.error?.(error instanceof Error ? error : new Error(String(error)));
-                }
-                return;
-            }
-            event.preventDefault();
-            event.stopPropagation();
-            if (events.clipboard) {
-                const epoch = instance.documentEpoch, revision = instance.revision;
-                const { from, to } = view.state.selection;
-                const cut = event.type === 'cut' && instance.writable;
-                const policyEpoch = instance.policyEpoch;
-                void instance
-                    .clipboardSnapshot(false)
-                    .then(async (content) => {
-                    if (cut &&
-                        (content.images.some((image) => image.error) ||
-                            content.diagrams?.some((diagram) => diagram.error)))
-                        throw new InkKitError('image-unavailable', 'The selected content could not be cut safely');
-                    await events.clipboard(content);
-                    if (cut) {
-                        instance.assertMutation();
-                        if (epoch !== instance.documentEpoch ||
-                            policyEpoch !== instance.policyEpoch ||
-                            revision !== instance.revision)
-                            throw new InkKitError('stale-document', 'Document changed before cutting');
-                        view.dispatch(view.state.tr.deleteRange(from, to).scrollIntoView());
-                    }
-                })
-                    .catch((error) => events.error?.(error instanceof Error ? error : new Error(String(error))));
-            }
-            else {
-                const container = document.createElement('div');
-                container.textContent = clipboardText(expanded);
-                event.clipboardData?.setData('text/plain', container.textContent ?? '');
-                event.clipboardData?.setData('text/html', container.outerHTML);
-                events.error?.(new InkKitError('image-unavailable', 'The host must provide a clipboard handler for portable images and diagrams'));
-            }
-        };
-        root.addEventListener('copy', instance.copyHandler, true);
-        root.addEventListener('cut', instance.copyHandler, true);
-        instance.applyInputPolicy();
-        instance.setKeymap(options.keymap ?? {});
-        return instance;
-    }
-    loadDocument(input) {
-        this.assertAlive();
-        const container = this.viewportContainer ?? this.root;
-        const top = container.scrollTop, left = container.scrollLeft;
-        const active = this.root.ownerDocument.activeElement;
-        if (active === this.plain ||
-            active === this.editor.ctx.get(editorViewCtx).dom)
-            active.blur();
-        this.ready = false;
-        this.cancelExports();
-        this.mediaPolicy();
-        this.pasteController.cancelPending();
-        this.documentEpoch += 1;
-        this.outlineEpoch += 1;
-        this.sourcePreservations = new WeakMap();
-        this.sourceTexts = new WeakMap();
-        this.pendingSource = undefined;
-        this.typedSteps = [];
-        this.undoneSteps = [];
-        this.formattedUndone = 0;
-        this.mode = 'formatted';
-        this.plainComposing = false;
-        this.beforePlainInput = undefined;
-        this.plainSearch = '';
-        this.literalMatch = undefined;
-        this.documentId = input.documentId;
-        this.formatType = input.format;
-        this.revision = 0;
-        this.plain.value = input.text;
-        this.plain.setSelectionRange(this.plain.value.length, this.plain.value.length);
-        this.load(input.format === 'txt' ? '' : input.text, input.generation);
-        this.originalSource = input.text;
-        this.lastMarkdown = input.text;
-        this.updateSurface();
-        this.ready = true;
-        this.mediaPolicy();
-        container.scrollTop = top;
-        container.scrollLeft = left;
-        this.events.stateChanged(this.literalSurface
-            ? { marks: [], block: { type: 'paragraph' }, quoted: false }
-            : caretState(this.editor.ctx.get(editorViewCtx).state));
-        this.publishCommandState();
-    }
-    reloadDocument(input) {
-        this.assertAlive();
-        const view = this.editor.ctx.get(editorViewCtx);
-        const wasLiteral = this.literalSurface;
-        const previousMode = this.editingMode;
-        const previousFormat = this.formatType;
-        const selectedNode = !wasLiteral && view.state.selection instanceof NodeSelection
-            ? view.state.selection.node
-            : undefined;
-        const at = wasLiteral
-            ? this.plain.selectionStart
-            : view.state.selection.anchor;
-        const end = wasLiteral ? this.plain.selectionEnd : view.state.selection.head;
-        const direction = this.plain.selectionDirection;
-        const container = this.viewportContainer ?? this.root;
-        const top = container.scrollTop, left = container.scrollLeft;
-        const focused = wasLiteral
-            ? document.activeElement === this.plain
-            : view.hasFocus();
-        const plainTop = this.plain.scrollTop, plainLeft = this.plain.scrollLeft;
-        this.reportingSuppressed = true;
-        try {
-            this.loadDocument(input);
-            if (previousFormat === 'md' &&
-                input.format === 'md' &&
-                previousMode === 'source')
-                this.setEditingMode('source', input.generation);
-            if (this.literalSurface)
-                this.plain.setSelectionRange(Math.min(at, this.plain.value.length), Math.min(end, this.plain.value.length), direction);
-            else {
-                const anchor = Math.min(at, view.state.doc.content.size);
-                const node = view.state.doc.nodeAt(anchor);
-                view.dispatch(view.state.tr.setSelection(selectedNode &&
-                    node?.type === selectedNode.type &&
-                    NodeSelection.isSelectable(node)
-                    ? NodeSelection.create(view.state.doc, anchor)
-                    : TextSelection.between(view.state.doc.resolve(anchor), view.state.doc.resolve(Math.min(end, view.state.doc.content.size)))));
-            }
-            if (focused) {
-                if (this.literalSurface)
-                    this.plain.focus({ preventScroll: true });
-                else
-                    view.focus();
-            }
-            container.scrollTop = top;
-            container.scrollLeft = left;
-            if (wasLiteral && this.literalSurface) {
-                this.plain.scrollTop = plainTop;
-                this.plain.scrollLeft = plainLeft;
-            }
-        }
-        finally {
-            this.reportingSuppressed = false;
-            this.publishCommandState();
-        }
-    }
-    setViewport(options) {
-        this.assertAlive();
-        const container = options.scrollContainer ?? this.root;
-        if (container !== this.root && !container.contains(this.root))
-            throw new RangeError('The scroll container must be the editor root or an ancestor');
-        const insets = { top: 0, right: 0, bottom: 0, left: 0, ...options.insets };
-        if (Object.values(insets).some((value) => !Number.isFinite(value) || value < 0))
-            throw new RangeError('Viewport insets must be finite non-negative CSS pixel values');
-        this.viewportContainer = container;
-        this.viewportInsets = insets;
-    }
-    viewport() {
-        this.assertAlive();
-        const container = this.viewportContainer ?? this.root;
-        const bounds = container.getBoundingClientRect();
-        const root = this.root.getBoundingClientRect();
-        const insets = this.viewportInsets;
-        const window = this.root.ownerDocument.defaultView;
-        const left = Math.max(bounds.left + container.clientLeft, root.left, 0);
-        const top = Math.max(bounds.top + container.clientTop, root.top, 0);
-        const right = Math.max(left, Math.min(bounds.left + container.clientLeft + container.clientWidth, root.right, window.innerWidth));
-        const bottom = Math.max(top, Math.min(bounds.top + container.clientTop + container.clientHeight, root.bottom, window.innerHeight));
-        let rect = textRect({ left, top, right, bottom });
-        if (this.literalSurface) {
-            const plain = this.plain.getBoundingClientRect();
-            const literalLeft = Math.max(rect.left, plain.left + this.plain.clientLeft);
-            const literalTop = Math.max(rect.top, plain.top + this.plain.clientTop);
-            rect = textRect({
-                left: literalLeft,
-                top: literalTop,
-                right: Math.max(literalLeft, Math.min(rect.right, plain.left + this.plain.clientLeft + this.plain.clientWidth)),
-                bottom: Math.max(literalTop, Math.min(rect.bottom, plain.top + this.plain.clientTop + this.plain.clientHeight)),
-            });
-        }
-        const insetLeft = Math.min(rect.right, rect.left + insets.left);
-        const insetTop = Math.min(rect.bottom, rect.top + insets.top);
-        rect = textRect({
-            left: insetLeft,
-            top: insetTop,
-            right: Math.max(insetLeft, rect.right - insets.right),
-            bottom: Math.max(insetTop, rect.bottom - insets.bottom),
-        });
-        return Object.freeze({
-            rect: Object.freeze(rect),
-            insets: Object.freeze({ ...insets }),
-            scrollTop: container.scrollTop + (this.literalSurface ? this.plain.scrollTop : 0),
-            scrollLeft: container.scrollLeft +
-                (this.literalSurface ? this.plain.scrollLeft : 0),
-        });
-    }
-    readableScope() {
-        const key = `${this.documentEpoch}:${this.revision}:${this.outlineEpoch}:${this.editingMode}`;
-        if (this.textScope?.key !== key)
-            this.textScope = {
-                key,
-                id: `${this.textIdentity}:${key}`,
-                projection: this.literalSurface
-                    ? { text: this.plain.value, spans: [] }
-                    : readableProjection(this.editor.ctx.get(editorViewCtx).state.doc),
-            };
-        return this.textScope;
-    }
-    textSnapshot(expectedGeneration) {
-        this.assertCurrent(expectedGeneration);
-        const scope = this.readableScope();
-        const selection = this.editor.ctx.get(editorViewCtx).state.selection;
-        return Object.freeze({
-            snapshotId: scope.id,
-            documentId: this.documentId,
-            generation: this.generation,
-            revision: this.revision,
-            format: this.formatType,
-            mode: this.editingMode,
-            text: scope.projection.text,
-            selection: Object.freeze({
-                snapshotId: scope.id,
-                from: this.literalSurface
-                    ? this.plain.selectionStart
-                    : projectionOffset(scope.projection, selection.from),
-                to: this.literalSurface
-                    ? this.plain.selectionEnd
-                    : projectionOffset(scope.projection, selection.to),
-            }),
-        });
-    }
-    validateTextRange(range) {
-        this.assertCurrent();
-        const scope = this.readableScope();
-        if (range.snapshotId !== scope.id)
-            throw new InkKitError('stale-document', 'The readable text snapshot changed');
-        validateOffsets(scope.projection.text, range.from, range.to);
-        return scope.projection;
-    }
-    selectTextRange(range, options = {}) {
-        const projection = this.validateTextRange(range);
-        if (this.literalSurface)
-            this.plain.setSelectionRange(range.from, range.to);
-        else {
-            for (const span of projection.spans)
-                if (span.kind === 'embed' &&
-                    ((range.from > span.from && range.from < span.to) ||
-                        (range.to > span.from && range.to < span.to)))
-                    throw new InkKitError('invalid-range', 'Embedded labels must be selected as complete ranges');
-            const view = this.editor.ctx.get(editorViewCtx);
-            const from = projectionPosition(projection, range.from, 1);
-            const to = projectionPosition(projection, range.to, range.from === range.to ? 1 : -1);
-            const embed = projection.spans.find((span) => span.kind === 'embed' &&
-                span.from === range.from &&
-                span.to === range.to);
-            view.dispatch(view.state.tr.setSelection(embed && view.state.doc.nodeAt(embed.start)
-                ? NodeSelection.create(view.state.doc, embed.start)
-                : TextSelection.between(view.state.doc.resolve(from), view.state.doc.resolve(to))));
-        }
-        if (options.focus) {
-            if (this.literalSurface)
-                this.plain.focus({ preventScroll: true });
-            else
-                this.editor.ctx.get(editorViewCtx).focus();
-        }
-        if (options.reveal)
-            this.revealTextRange(range);
-        this.publishCommandState();
-    }
-    /** Throws when a document reached by an edit, after every appended normalisation, cannot be
-     *  saved as preserved Markdown. Dispatch and the replacement commands share this check.
-     *  `written` is false for history steps and source replacement, which restore or supply a
-     *  document that may hold comment text the formatted editor would refuse to accept typed. */
-    assertPreserved(before, after, written = true) {
-        if (this.literalSurface || after.eq(before))
-            return;
-        if (written)
-            assertCommentsEndWhereWritten(before, after);
-        if (this.preservation)
-            this.currentText(after);
-    }
-    replaceTextRange(range, text) {
-        const projection = this.validateTextRange(range);
-        this.assertMutation();
-        if (typeof text !== 'string')
-            throw new TypeError('Replacement must be a string');
-        if (this.literalSurface) {
-            const raw = this.currentText();
-            const from = rawOffset(raw, range.from), to = rawOffset(raw, range.to);
-            const ending = /\r\n|\r|\n/.exec(raw)?.[0] ?? '\n';
-            const value = text.replace(/\r\n?/g, '\n');
-            const replaced = raw.slice(0, from) + value.replaceAll('\n', ending) + raw.slice(to);
-            return this.applySource(replaced, true, range.from, range.from + value.length);
-        }
-        if (projection.spans.some((span) => (span.kind === 'embed' &&
-            range.from > span.from &&
-            range.from < span.to) ||
-            (span.kind === 'embed' &&
-                range.to > span.from &&
-                range.to < span.to) ||
-            (span.to > range.from &&
-                span.from < range.to &&
-                span.kind !== 'text')))
-            throw new InkKitError('invalid-range', 'Replacement cannot remove embedded content or structural separators');
-        const from = projectionPosition(projection, range.from, 1);
-        const to = projectionPosition(projection, range.to, range.from === range.to ? 1 : -1);
-        const view = this.editor.ctx.get(editorViewCtx);
-        return replaceFormattedRange(view, from, to, text, (tr) => this.assertPreserved(view.state.doc, view.state.apply(tr).doc));
-    }
-    textRangeRects(range) {
-        return this.textRangesRects([range])[0];
-    }
-    textRangesRects(ranges) {
-        this.assertCurrent();
-        const projections = ranges.map((range) => this.validateTextRange(range));
-        if (!ranges.length)
-            return Object.freeze([]);
-        const results = this.literalSurface
-            ? literalRangesRects(this.plain, ranges)
-            : ranges.map((range, index) => formattedRects(this.editor.ctx.get(editorViewCtx), projections[index], range.from, range.to));
-        return Object.freeze(results.map((rects) => Object.freeze(rects.map((rect) => Object.freeze(rect)))));
-    }
-    visibleTextRanges(snapshotId) {
-        const snapshot = this.textSnapshot();
-        this.validateTextRange({ snapshotId, from: 0, to: 0 });
-        const viewport = this.viewport().rect;
-        if (this.literalSurface)
-            return Object.freeze(literalVisibleRanges(this.plain, viewport).map((range) => Object.freeze({ snapshotId, ...range })));
-        const visible = (rect) => intersectsViewport(rect, viewport);
-        const ranges = [];
-        const projection = this.readableScope().projection;
-        const view = this.editor.ctx.get(editorViewCtx);
-        for (const span of projection.spans) {
-            const current = { text: projection.text, spans: [span] };
-            if (span.kind === 'separator' ||
-                !formattedRects(view, current, span.from, span.to).some(visible))
-                continue;
-            for (let from = span.from; from < span.to;) {
-                const to = from + (snapshot.text.codePointAt(from) > 0xffff ? 2 : 1);
-                if (formattedRects(view, current, from, to).some(visible)) {
-                    const previous = ranges.at(-1);
-                    if (previous?.to === from)
-                        previous.to = to;
-                    else
-                        ranges.push({ snapshotId, from, to });
-                }
-                from = to;
-            }
-        }
-        return Object.freeze(ranges.map((range) => Object.freeze(range)));
-    }
-    revealTextRange(range) {
-        const projection = this.validateTextRange(range);
-        if (!this.literalSurface) {
-            const view = this.editor.ctx.get(editorViewCtx);
-            const position = projectionPosition(projection, range.from, 1);
-            const at = view.domAtPos(position).node;
-            let element = at instanceof Element ? at : at.parentElement;
-            while (element && this.root.contains(element)) {
-                if (element.matches('.inkkit-callout[data-inkkit-folded="true"]'))
-                    element
-                        .querySelector(':scope > .inkkit-callout-header [data-inkkit-callout-toggle]')
-                        ?.click();
-                element = element.parentElement;
-            }
-        }
-        this.revealRects(this.textRangeRects(range));
-    }
-    revealRects(rects) {
-        if (!rects.length)
-            return;
-        const viewport = this.viewport().rect;
-        const leading = rects[0];
-        const envelope = {
-            top: leading.top,
-            bottom: leading.bottom,
-            left: leading.left,
-            right: leading.right,
-        };
-        for (const rect of rects) {
-            envelope.top = Math.min(envelope.top, rect.top);
-            envelope.bottom = Math.max(envelope.bottom, rect.bottom);
-            envelope.left = Math.min(envelope.left, rect.left);
-            envelope.right = Math.max(envelope.right, rect.right);
-        }
-        const fitsHeight = envelope.bottom - envelope.top <= viewport.height;
-        const fitsWidth = envelope.right - envelope.left <= viewport.width;
-        const rect = {
-            top: fitsHeight ? envelope.top : leading.top,
-            bottom: fitsHeight
-                ? envelope.bottom
-                : Math.min(leading.bottom, leading.top + viewport.height),
-            left: fitsWidth ? envelope.left : leading.left,
-            right: fitsWidth
-                ? envelope.right
-                : Math.min(leading.right, leading.left + viewport.width),
-        };
-        const vertical = viewport.height <= 0
-            ? 0
-            : rect.top < viewport.top
-                ? rect.top - viewport.top
-                : rect.bottom > viewport.bottom
-                    ? rect.bottom - viewport.bottom
-                    : 0;
-        const horizontal = viewport.width <= 0
-            ? 0
-            : rect.left < viewport.left
-                ? rect.left - viewport.left
-                : rect.right > viewport.right
-                    ? rect.right - viewport.right
-                    : 0;
-        let remainingTop = vertical, remainingLeft = horizontal;
-        if (this.literalSurface) {
-            const style = this.root.ownerDocument.defaultView.getComputedStyle(this.plain);
-            // The first or last line sits within the padding plus its own leading,
-            // under half the height of its first rect, so a reveal that ends there
-            // shows the edge. A range of many lines does not count as one line.
-            const halfCaret = (leading.bottom - leading.top) / 2;
-            const remaining = scrollWholePixels(this.plain, vertical, horizontal, {
-                top: (Number.parseFloat(style.paddingTop) || 0) + halfCaret,
-                bottom: (Number.parseFloat(style.paddingBottom) || 0) + halfCaret,
-            });
-            remainingTop = remaining.vertical;
-            remainingLeft = remaining.horizontal;
-        }
-        let container = this.viewportContainer ?? this.root;
-        const document = this.root.ownerDocument;
-        while (container &&
-            container !== document.body &&
-            container !== document.documentElement) {
-            ;
-            ({ vertical: remainingTop, horizontal: remainingLeft } =
-                scrollWholePixels(container, remainingTop, remainingLeft));
-            container = container.parentElement;
-        }
-        if (remainingTop || remainingLeft)
-            document.defaultView.scrollBy(scrollOutward(remainingLeft), scrollOutward(remainingTop));
-    }
-    revealCurrentSelection() {
-        if (this.loading || !this.ready)
-            return;
-        if (this.literalSurface) {
-            this.revealLiteralSelection();
-            return;
-        }
-        const view = this.editor.ctx.get(editorViewCtx);
-        const projection = this.readableScope().projection;
-        const from = projectionOffset(projection, view.state.selection.from);
-        const to = projectionOffset(projection, view.state.selection.to);
-        if (this.composing || this.pasteController.pending) {
-            this.revealRects(formattedRects(view, projection, from, to));
-            return;
-        }
-        this.revealTextRange({
-            snapshotId: this.readableScope().id,
-            from,
-            to,
-        });
-    }
-    revealLiteralSelection() {
-        this.revealRects(literalRangesRects(this.plain, [
-            {
-                from: this.plain.selectionStart,
-                to: this.plain.selectionEnd,
-            },
-        ])[0]);
-    }
-    load(markdown, generation) {
-        this.generation = generation;
-        this.originalSource = markdown;
-        this.loading = true;
-        try {
-            this.editor.action(replaceAll(markdown, true));
-        }
-        finally {
-            this.loading = false;
-        }
-        this.preservation = new Preservation(this.editor.ctx, markdown);
-        this.lastMarkdown = markdown;
-        const view = this.editor.ctx.get(editorViewCtx);
-        // A caret at the end, where writing carries on; at the start it would sit in a first-line heading and
-        // show its marks. The last place text can go, so a document ending in a rule takes a caret above it
-        // rather than selecting the rule itself. After a final image, typing opens a paragraph below it.
-        const { doc } = view.state;
-        const $end = doc.resolve(doc.content.size);
-        const end = isImageBlock(doc.lastChild)
-            ? new GapCursor($end)
-            : (Selection.findFrom($end, -1, true) ?? Selection.atEnd(doc));
-        view.dispatch(setSearchState(view.state.tr.setSelection(end), new SearchQuery({ search: '' })));
-    }
-    find(text, expectedGeneration) {
-        this.assertCurrent(expectedGeneration);
-        if (this.literalSurface) {
-            const from = this.plainSearch === text
-                ? this.plain.selectionEnd
-                : this.plain.selectionStart;
-            const raw = this.currentText();
-            const match = findLiteral(raw, text, rawOffset(raw, from));
-            this.literalMatch = undefined;
-            if (match) {
-                // A textarea displays CRLF as one character; retain a match of either raw half for replacement.
-                const start = raw[match.from] === '\n' && raw[match.from - 1] === '\r'
-                    ? match.from - 1
-                    : match.from;
-                const displayedFrom = normalizedOffset(raw, start), displayedTo = normalizedOffset(raw, match.to);
-                this.plain.setSelectionRange(displayedFrom, displayedTo);
-                this.literalMatch = {
-                    ...match,
-                    query: text,
-                    displayedFrom,
-                    displayedTo,
-                    revision: this.revision,
-                    epoch: this.documentEpoch,
-                };
-            }
-            else if (this.plainSearch)
-                this.plain.setSelectionRange(this.plain.selectionEnd, this.plain.selectionEnd);
-            this.plainSearch = text;
-            this.revealLiteralSelection();
-            return;
-        }
-        if (findFormatted(this.editor.ctx.get(editorViewCtx), text))
-            this.revealCurrentSelection();
-    }
-    replace(search, replacement, expectedGeneration) {
-        this.assertMutation(expectedGeneration);
-        return this.replaceMatches(search, replacement, false) > 0;
-    }
-    replaceAll(search, replacement, expectedGeneration) {
-        this.assertMutation(expectedGeneration);
-        return this.replaceMatches(search, replacement, true);
-    }
-    replaceMatches(search, replacement, all) {
-        if (this.literalSurface) {
-            const raw = this.currentText();
-            const remembered = this.literalMatch;
-            const selection = remembered &&
-                remembered.query === search &&
-                remembered.revision === this.revision &&
-                remembered.epoch === this.documentEpoch &&
-                remembered.displayedFrom === this.plain.selectionStart &&
-                remembered.displayedTo === this.plain.selectionEnd
-                ? { from: remembered.from, to: remembered.to }
-                : {
-                    from: rawOffset(raw, this.plain.selectionStart),
-                    to: rawOffset(raw, this.plain.selectionEnd),
-                };
-            if (remembered?.query !== search)
-                this.literalMatch = undefined;
-            const result = replaceLiteral(raw, search, replacement, selection, all);
-            if (result.count)
-                this.applySource(result.text, true, normalizedOffset(result.text, result.from), normalizedOffset(result.text, result.to));
-            this.plainSearch = search;
-            return result.count;
-        }
-        const view = this.editor.ctx.get(editorViewCtx);
-        return replaceFormatted(view, search, replacement, (tr) => this.assertPreserved(view.state.doc, view.state.apply(tr).doc), all);
-    }
-    outlineContext() {
-        return {
-            documentId: this.documentId,
-            generation: this.generation,
-            revision: this.revision,
-            epoch: this.outlineEpoch,
-            mode: this.editingMode,
-        };
-    }
-    headings(expectedGeneration) {
-        this.assertCurrent(expectedGeneration);
-        if (this.formatType === 'txt')
-            return Object.freeze([]);
-        return this.mode === 'source'
-            ? collectSourceHeadings(this.editor.ctx, this.plain.value, this.outlineContext())
-            : collectFormattedHeadings(this.editor.ctx.get(editorViewCtx).state.doc, this.outlineContext());
-    }
-    navigateHeading(heading) {
-        this.assertCurrent();
-        if (!heading || typeof heading !== 'object')
-            throw new InkKitError('stale-document', 'The heading is no longer current');
-        this.assertCurrent(heading.generation);
-        if (this.formatType === 'txt')
-            throw new InkKitError('stale-document', 'The heading is no longer current');
-        if (this.mode === 'source') {
-            const position = sourceHeadingPosition(this.editor.ctx, this.plain.value, heading, this.outlineContext());
-            this.plain.setSelectionRange(position, position);
-            this.plain.focus({ preventScroll: true });
-            this.revealLiteralSelection();
-            return true;
-        }
-        return navigateFormattedHeading(this.editor.ctx.get(editorViewCtx), heading, this.outlineContext());
-    }
-    /** Buffered native typing follows the same input rules as direct typing. */
-    insertText(text, generation) {
-        this.assertAlive();
-        if ((this.literalSurface
-            ? this.plainComposing
-            : this.editor.ctx.get(editorViewCtx).composing) &&
-            generation === this.generation)
-            return false;
-        this.assertMutation(generation);
-        if (this.literalSurface) {
-            this.replaceLiteralSelection(text, false);
-            return true;
-        }
-        if (/[\r\n]/.test(text)) {
-            this.pasteAsPlainText(text);
-            return true;
-        }
-        const view = this.editor.ctx.get(editorViewCtx);
-        if (view.composing)
-            return false;
-        const { from, to } = view.state.selection;
-        const transaction = () => view.state.tr.insertText(text, from, to);
-        if (!view.someProp('handleTextInput', (handler) => handler(view, from, to, text, transaction))) {
-            view.dispatch(transaction().scrollIntoView());
-        }
-        return true;
-    }
-    /** Let existing keymaps handle buffered editing commands before native fallback. */
-    keyDown(key, code, metaKey, ctrlKey, altKey, shiftKey, generation) {
-        this.assertAlive();
-        if ((this.literalSurface
-            ? this.plainComposing
-            : this.editor.ctx.get(editorViewCtx).composing) &&
-            generation === this.generation)
-            return false;
-        this.assertCurrent(generation);
-        const configuredEvent = new KeyboardEvent('keydown', {
-            key,
-            code,
-            metaKey,
-            ctrlKey,
-            altKey,
-            shiftKey,
-            bubbles: true,
-            cancelable: true,
-        });
-        if (!this.literalSurface && altKey && key === 'Enter')
-            return this.navigateFootnote(shiftKey ? 'reference' : 'definition');
-        if (!this.writable &&
-            !this.literalSurface &&
-            key === 'Tab' &&
-            !metaKey &&
-            !ctrlKey &&
-            !altKey) {
-            const view = this.editor.ctx.get(editorViewCtx);
-            return goToNextCell(shiftKey ? -1 : 1)(view.state, view.dispatch);
-        }
-        if (!this.writable) {
-            if (['Enter', 'Tab', 'Backspace', 'Delete'].includes(key))
-                this.assertMutation(generation);
-            this.readOnlyKeys(this.editor.ctx.get(editorViewCtx), configuredEvent);
-        }
-        if (this.literalSurface) {
-            if (this.literalKeys(this.editor.ctx.get(editorViewCtx), configuredEvent))
-                return true;
-            if (!this.writable &&
-                ['Enter', 'Tab', 'Backspace', 'Delete'].includes(key))
-                throw new InkKitError('read-only', 'The editor is read-only');
-            if (metaKey || ctrlKey || altKey)
-                return false;
-            if (key === 'Enter' || key === 'Tab') {
-                this.replaceLiteralSelection(key === 'Enter' ? '\n' : '\t', false);
-                return true;
-            }
-            if (key === 'Backspace' || key === 'Delete') {
-                const start = this.plain.selectionStart, end = this.plain.selectionEnd;
-                if (start === end) {
-                    if (key === 'Backspace' && start > 0)
-                        this.plain.setSelectionRange(start - [...this.plain.value.slice(0, start)].at(-1).length, end);
-                    else if (key === 'Delete' && end < this.plain.value.length)
-                        this.plain.setSelectionRange(start, end + [...this.plain.value.slice(end)][0].length);
-                    else
-                        return false;
-                }
-                this.replaceLiteralSelection('', false);
-                return true;
-            }
-            return false;
-        }
-        const view = this.editor.ctx.get(editorViewCtx);
-        if (view.composing)
-            return false;
-        const event = new KeyboardEvent('keydown', {
-            key,
-            code,
-            metaKey,
-            ctrlKey,
-            altKey,
-            shiftKey,
-            bubbles: true,
-            cancelable: true,
-        });
-        return Boolean(view.someProp('handleKeyDown', (handler) => handler(view, event)));
-    }
-    focus() {
-        this.assertAlive();
-        if (!this.ready)
-            throw new InkKitError('not-ready', 'No document has been loaded');
-        if (this.literalSurface)
-            this.plain.focus();
-        else
-            this.editor.ctx.get(editorViewCtx).focus();
-    }
-    /** Binds keys, in ProseMirror's names, to the formatting each shortcut runs. Walked in the table's
-     *  order, so a key given to two shortcuts lands the same way every time. */
-    setKeymap(keymap) {
-        this.assertAlive();
-        this.configuredKeys = {
-            undo: ['Mod-z'],
-            redo: ['Mod-y', 'Shift-Mod-z'],
-            tableExit: ['Mod-Enter', 'Enter'],
-            ...keymap,
-        };
-        const bindings = {};
-        // Consuming unbound history keys prevents the browser's separate undo stack
-        // from changing source/TXT outside the shared document history.
-        const historyBindings = Object.fromEntries(['Mod-z', 'Mod-y', 'Shift-Mod-z'].map((key) => [key, () => true]));
-        for (const name of ['undo', 'redo']) {
-            for (const key of this.configuredKeys[name] ?? []) {
-                historyBindings[key] = () => {
-                    if (!this.ready || !this.commandState().commands[name])
-                        return true;
-                    return this[name]();
-                };
-            }
-        }
-        Object.assign(bindings, historyBindings);
-        for (const [name, command] of Object.entries(shortcutCommands)) {
-            for (const key of keymap[name] ?? []) {
-                bindings[key] = () => {
-                    if (!this.ready || !this.commandState().commands.format[command[0]])
-                        return true;
-                    this.format(...command);
-                    return true;
-                };
-            }
-        }
-        for (const command of tableCommands) {
-            const name = 'table' + command[0].toUpperCase() + command.slice(1);
-            for (const key of this.configuredKeys[name] ?? [])
-                bindings[key] = () => {
-                    if (!this.ready || !this.commandState().commands.table[command])
-                        return false;
-                    return this.table(command);
-                };
-        }
-        this.readOnlyKeys = keydownHandler(Object.fromEntries(Object.keys(bindings).map((key) => [
-            key,
-            () => {
-                throw new InkKitError('read-only', 'The editor is read-only');
-            },
-        ])));
-        this.keys = keydownHandler(bindings);
-        this.literalKeys = keydownHandler(historyBindings);
-    }
-    /** Dropped files land as one paragraph per path at the drop point: in place of an empty block, after
-     *  the top-level block otherwise, so a list or quote is not opened up by them. */
-    insertPaths(paths, x, y) {
-        this.assertMutation();
-        if (paths.length === 0)
-            return;
-        if (this.literalSurface) {
-            this.pasteAsPlainText(paths.join('\n\n'));
-            return;
-        }
-        const { schema } = this.editor.ctx.get(editorViewCtx).state;
-        this.insertBlocks(paths.map((path) => schema.nodes.paragraph.create(null, schema.text(path))), x, y);
-    }
-    insertImages(images, x, y) {
-        this.assertMutation();
-        if (!images.length)
-            return;
-        if (!this.options.images || this.literalSurface)
-            throw new InkKitError('image-unavailable', 'This editor has no image adapter');
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { schema } = view.state;
-        const placement = x != null && y != null ? undefined : imagePlacement(view.state);
-        if (placement?.kind === 'inline') {
-            this.insertInline(images);
-            return;
-        }
-        // One paragraph per image: each is read back as a standalone image block where one fits.
-        const blocks = images.map((image) => schema.nodes.paragraph.create(null, schema.nodes.image.create({
-            src: image.path,
-            alt: image.alt,
-            title: image.title ?? '',
-        })));
-        if (x != null && y != null) {
-            this.insertBlocks(blocks, x, y);
-            return;
-        }
-        const tr = placement?.kind === 'after'
-            ? view.state.tr.insert(placement.pos, blocks)
-            : view.state.tr.replaceSelection(new Slice(Fragment.fromArray(blocks), 0, 0));
-        // After the last image, so typing continues below it rather than in the block that follows.
-        const last = blocks.at(-1).firstChild;
-        let after;
-        tr.doc.descendants((node, pos) => {
-            if (node === last)
-                after = pos + node.nodeSize;
-            return after == null;
-        });
-        if (after != null)
-            tr.setSelection(TextSelection.create(tr.doc, after));
-        view.dispatch(tr.scrollIntoView());
-    }
-    // A table cell holds one line, so the images sit side by side where the selection was, with no
-    // space between them: a space beside an image in a cell is saved as `&#x20;`.
-    insertInline(images) {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { state } = view;
-        const oneLine = (text) => text.replace(/\s*[\r\n]+\s*/g, ' ');
-        const nodes = images.map((image) => state.schema.nodes.image.create({
-            src: image.path,
-            alt: oneLine(image.alt),
-            title: oneLine(image.title ?? ''),
-        }));
-        const { from, to } = state.selection;
-        const tr = state.tr.replaceWith(from, to, nodes);
-        tr.setSelection(TextSelection.create(tr.doc, from + nodes.length));
-        view.dispatch(tr.scrollIntoView());
-    }
-    insertBlocks(blocks, x, y) {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { from: at, to } = blockDropRange(view, x, y);
-        const tr = view.state.tr.replaceWith(at, to, blocks);
-        const end = at + blocks.reduce((size, node) => size + node.nodeSize, 0) - 1;
-        view.dispatch(tr.setSelection(TextSelection.create(tr.doc, end)).scrollIntoView());
-        this.focus();
-    }
-    // Removing a mark at a caret only clears the stored mark, so the whole marked
-    // run is selected for the command and the caret put back after it.
-    withMarkRunSelected(mark, command) {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { selection, doc } = view.state;
-        if (!selection.empty)
-            return false;
-        const $pos = selection.$from;
-        const parent = $pos.parent;
-        const start = $pos.start();
-        let from = $pos.pos;
-        let to = $pos.pos;
-        parent.forEach((child, offset) => {
-            const childFrom = start + offset;
-            const childTo = childFrom + child.nodeSize;
-            if (!mark.isInSet(child.marks))
-                return;
-            if (childTo >= $pos.pos && childFrom <= to) {
-                from = Math.min(from, childFrom);
-                to = Math.max(to, childTo);
-            }
-        });
-        if (from === to)
-            return false;
-        view.dispatch(view.state.tr.setSelection(TextSelection.create(doc, from, to)));
-        command();
-        const caret = Math.min($pos.pos, view.state.doc.content.size);
-        view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, caret)));
-        return true;
-    }
-    // Milkdown's inline code command ignores a caret; a stored mark makes the
-    // next typed text code, the way bold and italic behave.
-    toggleInlineCode() {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const type = inlineCodeSchema.type(this.editor.ctx);
-        const run = () => {
-            this.editor.action(callCommand(toggleInlineCodeCommand.key));
-        };
-        const { selection, storedMarks } = view.state;
-        if (!selection.empty)
-            return run();
-        // A pending stored mark is only that; the span next to the caret is left alone.
-        if (storedMarks) {
-            const tr = type.isInSet(storedMarks)
-                ? view.state.tr.removeStoredMark(type)
-                : view.state.tr.addStoredMark(type.create());
-            return view.dispatch(tr);
-        }
-        if (!type.isInSet(selection.$from.marks()))
-            view.dispatch(view.state.tr.addStoredMark(type.create()));
-        else
-            this.withMarkRunSelected(type, run);
-    }
-    list(kind) {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { state } = view;
-        const { $from } = textBounds(state);
-        const wanted = kind === 'bulletList' ? 'bullet_list' : 'ordered_list';
-        const depth = innermostListDepth($from);
-        if (depth == null) {
-            const command = kind === 'bulletList'
-                ? wrapInBulletListCommand
-                : wrapInOrderedListCommand;
-            this.editor.action(callCommand(command.key));
-            return;
-        }
-        const list = $from.node(depth);
-        if (list.type.name === wanted) {
-            liftItem(state, view.dispatch);
-            return;
-        }
-        // The items carry the list kind too, and a bullet list whose items say
-        // ordered is turned back into one by the preset.
-        const pos = $from.before(depth);
-        const ordered = wanted === 'ordered_list';
-        const attrs = ordered
-            ? { order: 1, spread: list.attrs.spread }
-            : { spread: list.attrs.spread };
-        let tr = state.tr.setNodeMarkup(pos, state.schema.nodes[wanted], attrs);
-        list.forEach((item, offset) => {
-            tr = tr.setNodeMarkup(pos + 1 + offset, undefined, {
-                ...item.attrs,
-                listType: ordered ? 'ordered' : 'bullet',
-                label: ordered ? '1.' : '•',
-            });
-        });
-        view.dispatch(tr);
-    }
-    quote() {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const type = blockquoteSchema.type(this.editor.ctx);
-        const { $from, $to } = textBounds(view.state);
-        let range = $from.blockRange($to);
-        let wrapping = range && findWrapping(range, type);
-        if (!wrapping) {
-            // A list item cannot hold a quote, so the whole list is quoted instead.
-            const depth = outermostListDepth($from);
-            if (depth == null)
-                return;
-            const doc = view.state.doc;
-            range = new NodeRange(doc.resolve($from.before(depth)), doc.resolve($from.after(depth)), depth - 1);
-            wrapping = findWrapping(range, type);
-        }
-        if (!range || !wrapping)
-            return;
-        view.dispatch(view.state.tr.wrap(range, wrapping));
-    }
-    unquote() {
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { $from, $to } = textBounds(view.state);
-        const range = $from.blockRange($to, (node) => node.type.name === 'blockquote');
-        if (!range)
-            return;
-        const target = liftTarget(range);
-        if (target == null)
-            return;
-        view.dispatch(view.state.tr.lift(range, target));
-    }
-    format(command, arg) {
-        this.assertMutation();
-        if (this.literalSurface)
-            return;
-        const run = (cmd, payload) => this.editor.action(callCommand(cmd, payload));
-        const state = caretState(this.editor.ctx.get(editorViewCtx).state);
-        switch (command) {
-            case 'heading': {
-                const level = Number(arg ?? 1);
-                if (state.block.type === 'heading' && state.block.level === level)
-                    run(turnIntoTextCommand.key);
-                else
-                    run(wrapInHeadingCommand.key, level);
-                break;
-            }
-            case 'paragraph':
-                run(turnIntoTextCommand.key);
-                break;
-            case 'bold':
-                run(toggleStrongCommand.key);
-                break;
-            case 'italic':
-                run(toggleEmphasisCommand.key);
-                break;
-            case 'strikethrough':
-                run(toggleStrikethroughCommand.key);
-                break;
-            case 'highlight':
-                run(toggleHighlightCommand.key);
-                break;
-            case 'code':
-                this.toggleInlineCode();
-                break;
-            case 'codeBlock':
-                if (state.block.type === 'codeBlock')
-                    run(turnIntoTextCommand.key);
-                else
-                    run(createCodeBlockCommand.key, typeof arg === 'string' ? arg : '');
-                break;
-            case 'quote':
-                if (state.quoted)
-                    this.unquote();
-                else
-                    this.quote();
-                break;
-            case 'bulletList':
-            case 'orderedList':
-                this.list(command);
-                break;
-            case 'taskList':
-                toggleTaskList(this.editor.ctx);
-                break;
-            case 'link': {
-                const view = this.editor.ctx.get(editorViewCtx);
-                const reference = view.state.selection.$from
-                    .marks()
-                    .find((mark) => mark.type.name === 'link' && mark.attrs.identifier) ??
-                    view.state.doc
-                        .nodeAt(view.state.selection.from)
-                        ?.marks.find((mark) => mark.type.name === 'link' && mark.attrs.identifier);
-                if (reference && typeof arg === 'string') {
-                    this.editReferenceDefinition(String(reference.attrs.identifier), arg);
-                    break;
-                }
-                const payload = typeof arg === 'string' ? { href: arg } : {};
-                const toggle = () => run(toggleLinkCommand.key, payload);
-                if (!state.marks.includes('link') ||
-                    !this.withMarkRunSelected(linkSchema.type(this.editor.ctx), toggle))
-                    toggle();
-                break;
-            }
-        }
-        this.focus();
-    }
-    editReferenceDefinition(label, destination, title) {
-        this.assertMutation();
-        if (this.literalSurface)
-            return false;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const definitions = referenceDefinitions(view.state.doc);
-        const definition = definitions.get(normaliseLabel(label)) ??
-            [...definitions.values()].find(({ node }) => normaliseLabel(String(node.attrs.label)) === normaliseLabel(label));
-        if (!definition)
-            return false;
-        view.dispatch(view.state.tr.setNodeMarkup(definition.pos, undefined, {
-            ...definition.node.attrs,
-            url: destination,
-            title: title == null ? definition.node.attrs.title : singleLine(title),
-        }));
-        return true;
-    }
-    insertFootnote(label) {
-        this.assertMutation();
-        if (this.literalSurface)
-            return;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const definitions = footnoteDefinitions(view.state.doc);
-        if (label == null) {
-            let number = 1;
-            const labels = new Set(definitions.keys());
-            for (const match of this.snapshot().text.matchAll(/\[\^([^\]\r\n]+)\]/g))
-                labels.add(normaliseLabel(match[1]));
-            view.state.doc.descendants((node) => {
-                if (node.type.name === 'footnote_reference')
-                    labels.add(String(node.attrs.identifier));
-            });
-            while (labels.has(normaliseLabel(String(number))))
-                number++;
-            label = String(number);
-        }
-        if (!label || /[\s\[\]\\]/.test(label) || label.length > 999)
-            throw new Error('A footnote label must be 1–999 characters without whitespace, brackets or backslashes');
-        const identifier = normaliseLabel(label);
-        const reference = view.state.schema.nodes.footnote_reference.create({
-            label,
-            identifier,
-        });
-        const tr = view.state.tr.insert(view.state.selection.to, reference);
-        if (!definitions.has(identifier)) {
-            const definition = view.state.schema.nodes.footnote_definition.create({ label, identifier }, view.state.schema.nodes.paragraph.create());
-            const position = tr.doc.content.size;
-            tr.insert(position, definition).setSelection(TextSelection.create(tr.doc, position + 2));
-        }
-        view.dispatch(tr.scrollIntoView());
-        this.focus();
-    }
-    navigateFootnote(target) {
-        this.assertCurrent();
-        if (this.literalSurface)
-            return false;
-        const view = this.editor.ctx.get(editorViewCtx);
-        const { $from } = view.state.selection;
-        let identifier;
-        for (let depth = $from.depth; depth > 0; depth--) {
-            const node = $from.node(depth);
-            if (node.type.name === 'footnote_definition')
-                identifier = String(node.attrs.identifier);
-        }
-        const at = view.state.doc.nodeAt(view.state.selection.from);
-        const adjacent = at?.type.name === 'footnote_reference' ? at : $from.nodeBefore;
-        if (adjacent?.type.name === 'footnote_reference')
-            identifier = String(adjacent.attrs.identifier);
-        if (!identifier)
-            return false;
-        let position;
-        if (target === 'definition') {
-            const found = footnoteDefinitions(view.state.doc).get(identifier);
-            if (found)
-                position = found.pos + 2;
-        }
-        else
-            view.state.doc.descendants((node, pos) => {
-                if (position == null &&
-                    node.type.name === 'footnote_reference' &&
-                    node.attrs.identifier === identifier)
-                    position = pos;
-            });
-        if (position == null)
-            return false;
-        view.dispatch(view.state.tr
-            .setSelection(TextSelection.near(view.state.doc.resolve(position)))
-            .scrollIntoView());
-        this.focus();
-        return true;
-    }
-}