@rathkit/rte-core 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/engine.js

@@ -3,8 +3,10 @@ import { detectPlatform, Keymap } from "./keymap.js";
 import { emptyDoc } from "./model.js";
 import { caret, isCollapsed, pathKey } from "./path.js";
 import { startOf } from "./edit.js";
+import { contentPolicy } from "./policy.js";
 import { countDocument, countSelection, textLength } from "./stats.js";
 import { UiRegistry } from "./ui.js";
+import { describeError } from "./warning.js";
 import { PLUGIN_API_VERSION, satisfiesApi } from "./plugin.js";
 import { ops } from "./ops.js";
 const sameSelection = (a, b) => a === b || (a.anchor.offset === b.anchor.offset && a.focus.offset === b.focus.offset && pathKey(a.anchor.path) === pathKey(b.anchor.path) && pathKey(a.focus.path) === pathKey(b.focus.path));
@@ -17,6 +19,8 @@ export class Engine {
     behaviors = {};
     textTriggers = [];
     pasteTransforms = [];
+    copyFormatters = [];
+    normalizers = [];
     fileHandlers = [];
     importOptions = { recognizers: [] };
     doc;
@@ -40,7 +44,8 @@ export class Engine {
     focusRequest;
     maxLength;
     onMaxLength;
-    warn;
+    report;
+    warn = (message) => this.report({ code: "plugin-message", message });
     constructor(options = {}) {
         this.doc = options.doc ?? emptyDoc;
         this.sel = caret(startOf(this.doc));
@@ -49,8 +54,19 @@ export class Engine {
         this.focusRequest = options.focus;
         this.maxLength = options.maxLength;
         this.onMaxLength = options.onMaxLength;
-        this.warn = options.onWarning ?? ((message) => console.warn(`[rte] ${message}`));
-        this.keymap = new Keymap(options.platform ?? detectPlatform(), this.warn);
+        const handler = options.onWarning ?? ((w) => console.warn(`[rte] ${w.code}: ${w.message}`));
+        this.report = (warning) => { try {
+            handler(warning);
+        }
+        catch { } };
+        const policy = contentPolicy(options.content, (message) => this.report({ code: "bad-option", message }));
+        Object.assign(this.importOptions, {
+            linkSchemes: policy.linkSchemes, styles: policy.styles, maxDataImageLength: policy.maxDataImageLength,
+            maxDepth: policy.maxDepth, maxInputLength: policy.maxInputLength, pasteRelativeImages: policy.pasteRelativeImages,
+            onLimit: (info) => this.report({ code: "content-too-long", message: `Content of ${info.length} characters was not read: the limit is ${info.max} (content.maxInputLength).` }),
+            onError: (error) => this.report({ code: "content-unreadable", message: `Content could not be read and was left out: ${describeError(error)}`, error }),
+        });
+        this.keymap = new Keymap(options.platform ?? detectPlatform(), (message) => this.report({ code: "key-conflict", message }));
         this.commands = new CommandRegistry(this);
         this.current = this.makeSnapshot();
         this.notified = this.current;
@@ -102,12 +118,12 @@ export class Engine {
             return;
         this.notified = snapshot;
         for (const listener of [...this.listeners])
-            listener(snapshot, previous);
+            this.attempt(undefined, "a change listener", () => listener(snapshot, previous), undefined, "listener-failed");
         for (const sub of [...this.selectors]) {
             const value = sub.select(snapshot);
             if (!sub.equals(value, sub.last)) {
                 sub.last = value;
-                sub.onChange(value);
+                this.attempt(undefined, "a selector callback", () => sub.onChange(value), undefined, "listener-failed");
             }
         }
         this.commands.flush();
@@ -123,7 +139,7 @@ export class Engine {
             return false;
         this.refresh();
         const before = { doc: this.doc, selection: this.sel };
-        const result = op(this.doc, this.sel);
+        const result = this.settle(op(this.doc, this.sel));
         if (result.doc === this.doc && sameSelection(result.selection, this.sel))
             return false;
         const docChanged = result.doc !== this.doc;
@@ -143,16 +159,23 @@ export class Engine {
             }
             this.lastKind = kind;
             this.redoStack = [];
+            const top = this.undoStack[this.undoStack.length - 1];
+            if (top)
+                top.after = result.selection;
         }
         this.doc = result.doc;
         this.sel = result.selection;
         this.commit({ docChanged, selectionChanged: !sameSelection(before.selection, this.sel) });
         return true;
     }
+    settle(result) {
+        return result.doc === this.doc ? result : this.normalizers.reduce((r, normalize) => normalize(r.doc, r.selection), result);
+    }
     setSelection(selection) {
         if (sameSelection(selection, this.sel))
             return;
         this.sel = selection;
+        this.lastKind = "";
         this.commit({ docChanged: false, selectionChanged: true });
     }
     setPluginState(id, value) {
@@ -167,6 +190,7 @@ export class Engine {
         this.refresh();
         if (!isCollapsed(this.sel))
             return false;
+        this.lastKind = "";
         this.stored = { path: this.sel.focus.path, offset: this.sel.focus.offset, marks };
         this.commit({ docChanged: false, selectionChanged: false });
         return true;
@@ -184,8 +208,9 @@ export class Engine {
         this.commit({ docChanged: false, selectionChanged: false });
     }
     setDocument(doc, selection) {
-        this.doc = doc;
-        this.sel = selection ?? caret(startOf(doc));
+        const settled = this.settle({ doc, selection: selection ?? caret(startOf(doc)) });
+        this.doc = settled.doc;
+        this.sel = settled.selection;
         this.undoStack = [];
         this.redoStack = [];
         this.lastKind = "";
@@ -199,7 +224,7 @@ export class Engine {
                 this.undoStack.push(level);
             return false;
         }
-        this.redoStack.push({ doc: this.doc, selection: this.sel });
+        this.redoStack.push({ doc: this.doc, selection: level.after ?? this.sel });
         return this.restore(level);
     }
     redo() {
@@ -209,7 +234,7 @@ export class Engine {
                 this.redoStack.push(level);
             return false;
         }
-        this.undoStack.push({ doc: this.doc, selection: this.sel });
+        this.undoStack.push({ doc: this.doc, selection: this.sel, after: level.selection });
         return this.restore(level);
     }
     restore(level) {
@@ -249,6 +274,16 @@ export class Engine {
         }
         return undefined;
     }
+    attempt(plugin, where, fn, fallback, code = "plugin-failed") {
+        try {
+            return fn();
+        }
+        catch (error) {
+            const who = plugin ?? "a listener";
+            this.report({ code: plugin ? code : "listener-failed", ...(plugin ? { plugin } : {}), message: `${who} failed in ${where}; it was skipped: ${describeError(error)}`, error });
+            return fallback?.();
+        }
+    }
     use(plugin) {
         if (this.plugins.has(plugin.id))
             throw new Error(`The plugin ${plugin.id} is already registered.`);
@@ -256,10 +291,18 @@ export class Engine {
             throw new Error(`The plugin ${plugin.id} needs plugin API ${plugin.api}; this editor has ${PLUGIN_API_VERSION}.`);
         }
         const undo = [];
+        const safe = (where, fn, fallback) => ((...args) => this.attempt(plugin.id, where, () => fn(...args), () => fallback(...args)));
         const host = {
             editor: this,
             ops,
-            command: (def) => { undo.push(this.commands.register(def)); },
+            command: (def) => {
+                const guarded = {
+                    ...def,
+                    run: safe(`the command ${def.name}`, def.run.bind(def), () => false),
+                    ...(def.state ? { state: safe(`the state of ${def.name}`, def.state.bind(def), () => ({ enabled: false })) } : {}),
+                };
+                undo.push(this.commands.register(guarded));
+            },
             keybinding: (binding) => {
                 this.keymap.add(binding, plugin.id);
                 undo.push(() => this.keymap.remove(binding.command));
@@ -267,10 +310,15 @@ export class Engine {
             behavior: (kind, behavior) => {
                 if (this.behaviors[kind])
                     throw new Error(`The container ${kind} already has a behavior; ${plugin.id} cannot add another.`);
-                this.behaviors[kind] = behavior;
+                this.behaviors[kind] = {
+                    ...(behavior.split ? { split: safe(`the ${kind} split behavior`, behavior.split.bind(behavior), () => undefined) } : {}),
+                    ...(behavior.backspaceAtStart ? { backspaceAtStart: safe(`the ${kind} backspace behavior`, behavior.backspaceAtStart.bind(behavior), () => undefined) } : {}),
+                    ...(behavior.insertBlocks ? { insertBlocks: safe(`the ${kind} paste behavior`, behavior.insertBlocks.bind(behavior), () => undefined) } : {}),
+                };
                 undo.push(() => { delete this.behaviors[kind]; });
             },
-            textTrigger: (trigger) => {
+            textTrigger: (given) => {
+                const trigger = safe("a text trigger", given, () => undefined);
                 this.textTriggers.push(trigger);
                 undo.push(() => { const i = this.textTriggers.indexOf(trigger); if (i !== -1)
                     this.textTriggers.splice(i, 1); });
@@ -279,41 +327,83 @@ export class Engine {
                 if (options.sanitizeSvg) {
                     if (this.importOptions.sanitizeSvg)
                         throw new Error(`${plugin.id} cannot set an SVG cleaner: one is already set.`);
-                    this.importOptions.sanitizeSvg = options.sanitizeSvg;
+                    this.importOptions.sanitizeSvg = safe("the SVG cleaner", options.sanitizeSvg, () => undefined);
                 }
-                const added = options.recognizers ?? [];
+                const added = (options.recognizers ?? []).map((r) => ({
+                    ...(r.element ? { element: safe("a recognizer", r.element.bind(r), () => undefined) } : {}),
+                    ...(r.listItemStyle ? { listItemStyle: safe("a recognizer", r.listItemStyle.bind(r), () => undefined) } : {}),
+                }));
                 this.importOptions.recognizers = [...this.importOptions.recognizers, ...added];
                 undo.push(() => {
-                    if (options.sanitizeSvg && this.importOptions.sanitizeSvg === options.sanitizeSvg)
+                    if (options.sanitizeSvg)
                         delete this.importOptions.sanitizeSvg;
                     this.importOptions.recognizers = this.importOptions.recognizers.filter((r) => !added.includes(r));
                 });
             },
-            pasteTransform: (transform) => {
+            normalize: (given) => {
+                const normalizer = safe("a normalizer", given, (doc, selection) => ({ doc, selection }));
+                this.normalizers.push(normalizer);
+                undo.push(() => { const i = this.normalizers.indexOf(normalizer); if (i !== -1)
+                    this.normalizers.splice(i, 1); });
+            },
+            pasteTransform: (given) => {
+                const transform = (blocks) => {
+                    const failed = (error) => { this.report({ code: "plugin-failed", plugin: plugin.id, message: `${plugin.id} failed in a paste transform and was skipped: ${describeError(error)}`, error }); return blocks; };
+                    try {
+                        const out = given(blocks);
+                        return out instanceof Promise ? out.catch(failed) : out;
+                    }
+                    catch (error) {
+                        return failed(error);
+                    }
+                };
                 this.pasteTransforms.push(transform);
                 undo.push(() => { const i = this.pasteTransforms.indexOf(transform); if (i !== -1)
                     this.pasteTransforms.splice(i, 1); });
             },
             ui: (slot, item) => { undo.push(this.ui.add(slot, item)); },
-            fileHandler: (handler) => {
+            fileHandler: (given) => {
+                const handler = async (files) => {
+                    try {
+                        return await given(files);
+                    }
+                    catch (error) {
+                        this.report({ code: "plugin-failed", plugin: plugin.id, message: `${plugin.id} failed in a file handler and was skipped: ${describeError(error)}`, error });
+                        return undefined;
+                    }
+                };
                 this.fileHandlers.push(handler);
                 undo.push(() => { const i = this.fileHandlers.indexOf(handler); if (i !== -1)
                     this.fileHandlers.splice(i, 1); });
             },
-            pasteHandler: (handler) => {
+            copyFormat: (given) => {
+                const formatter = safe("a copy formatter", given, () => undefined);
+                this.copyFormatters.push(formatter);
+                undo.push(() => { const i = this.copyFormatters.indexOf(formatter); if (i !== -1)
+                    this.copyFormatters.splice(i, 1); });
+            },
+            pasteHandler: (given) => {
+                const handler = safe("a paste handler", given, () => undefined);
                 this.pasteHandlers.push(handler);
                 undo.push(() => { const i = this.pasteHandlers.indexOf(handler); if (i !== -1)
                     this.pasteHandlers.splice(i, 1); });
             },
         };
-        const teardown = plugin.setup(host);
-        if (teardown)
-            undo.push(teardown);
         const remove = () => {
             for (const fn of undo.reverse())
-                fn();
+                this.attempt(plugin.id, "taking the plugin away", fn, undefined);
             this.plugins.delete(plugin.id);
         };
+        try {
+            const teardown = plugin.setup(host);
+            if (teardown)
+                undo.push(teardown);
+        }
+        catch (error) {
+            remove();
+            this.report({ code: "plugin-failed", plugin: plugin.id, message: `${plugin.id} failed to start and was left out: ${describeError(error)}`, error });
+            return () => undefined;
+        }
         this.plugins.set(plugin.id, remove);
         return remove;
     }

package/dist/export.d.ts

@@ -1,4 +1,4 @@
-import type { Block, Doc, Inline } from "./model.ts";
+import { type Block, type Doc, type Inline } from "./model.ts";
 export declare function exportInline(content: readonly Inline[]): string;
 export declare function exportBlock(block: Block): string;
-export declare const exportHtml: (doc: Doc, separator?: string) => string;
+export declare function exportHtml(doc: Doc, separator?: string): string;

package/dist/export.js

@@ -1,5 +1,7 @@
 import { escapeAttribute, escapeText } from "./html/entities.js";
 import { lineCss, SIDES } from "./cellborder.js";
+import { noteIds } from "./notes.js";
+import { DEFAULT_MARKER } from "./model.js";
 const MARK_ORDER = ["link", "bold", "italic", "underline", "strike", "code", "sup", "sub", "color", "background"];
 const TAGS = { bold: "strong", italic: "em", underline: "u", strike: "s", code: "code", sup: "sup", sub: "sub" };
 function openClose(mark) {
@@ -28,11 +30,14 @@ function exportImage(node, placed) {
         + `${node.width !== undefined ? ` width="${node.width}"` : ""}${node.height !== undefined ? ` height="${node.height}"` : ""}`
         + `${placed && node.align ? ` style="${IMAGE_ALIGN_STYLE[node.align]}"` : ""}${placed && node.caption ? ` data-caption="${escapeAttribute(node.caption)}"` : ""}>`;
 }
+let numbers = [];
 export function exportInline(content) {
     let out = "";
     content.forEach((node, i) => {
         if (node.type === "br")
             out += "<br>";
+        else if (node.type === "note")
+            out += `<sup data-note="${node.id}"><a href="#fn-${node.id}" id="fnref-${node.id}" role="doc-noteref">${numbers.indexOf(node.id) + 1 || ""}</a></sup>`;
         else if (node.type === "image")
             out += exportImage(node, true);
         else {
@@ -52,12 +57,11 @@ const blockStyle = (block) => {
     return parts.length > 0 ? ` style="${parts.join("; ")};"` : "";
 };
 const dirAttr = (dir) => (dir ? ` dir="${dir}"` : "");
-const DEFAULT_MARKER = (type, depth) => (type === "ol" ? "decimal" : ["disc", "circle", "square"][Math.min(depth, 2)]);
 function exportList(list, depth) {
     const style = list.style !== undefined && list.style !== DEFAULT_MARKER(list.type, depth) ? ` style="list-style-type: ${list.style};"` : "";
     const start = list.type === "ol" && list.start !== undefined ? ` start="${list.start}"` : "";
     const items = list.items.map((item) => {
-        const noMarker = item.checked !== undefined || (item.content.length === 0 && item.sublists.length > 0);
+        const noMarker = item.checked !== undefined || (item.bare === true && item.content.length === 0 && (item.children[0]?.type === "ul" || item.children[0]?.type === "ol"));
         const box = item.checked === undefined ? "" : `<input type="checkbox" disabled${item.checked ? " checked" : ""}> `;
         const paragraphs = [[]];
         for (const node of item.content) {
@@ -67,9 +71,12 @@ function exportList(list, depth) {
                 paragraphs[paragraphs.length - 1].push(node);
         }
         const text = paragraphs.length === 1 ? exportInline(item.content) : paragraphs.map((part, i) => `<p>${i === 0 ? box : ""}${exportInline(part)}</p>`).join("");
-        return `<li${noMarker ? ' style="list-style-type: none;"' : ""}>${paragraphs.length === 1 ? box : ""}${text}${item.sublists.map((sub) => exportList(sub, depth + 1)).join("")}</li>`;
-    }).join("");
-    return `<${list.type}${start}${style}>${items}</${list.type}>`;
+        const inner = `${paragraphs.length === 1 ? box : ""}${text}${item.children.map((child) => (child.type === "ul" || child.type === "ol" ? exportList(child, depth + 1) : exportBlock(child))).join("")}`;
+        return list.notes ? inner : `<li${noMarker ? ' style="list-style-type: none;"' : ""}>${inner}</li>`;
+    });
+    if (list.notes)
+        return `<section class="footnotes" role="doc-endnotes"><ol>${list.items.map((item, i) => `<li id="fn-${item.id}" data-note="${item.id}">${items[i]} <a href="#fnref-${item.id}" role="doc-backlink">\u21A9\uFE0E</a></li>`).join("")}</ol></section>`;
+    return `<${list.type}${start}${style}>${items.join("")}</${list.type}>`;
 }
 function cellStyle(cell) {
     const parts = [];
@@ -116,4 +123,13 @@ export function exportBlock(block) {
         case "hr": return "<hr>";
     }
 }
-export const exportHtml = (doc, separator = "") => doc.blocks.map(exportBlock).join(separator);
+export function exportHtml(doc, separator = "") {
+    const outer = numbers;
+    numbers = noteIds(doc);
+    try {
+        return doc.blocks.map(exportBlock).join(separator);
+    }
+    finally {
+        numbers = outer;
+    }
+}

package/dist/footnotes/index.d.ts

@@ -0,0 +1,2 @@
+export { footnotes, type FootnotesOptions } from "./plugin.ts";
+export { createReconciler } from "./reconcile.ts";

package/dist/footnotes/index.js

@@ -0,0 +1,2 @@
+export { footnotes } from "./plugin.js";
+export { createReconciler } from "./reconcile.js";

package/dist/footnotes/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "../plugin.ts";
+export interface FootnotesOptions {
+    /** Ctrl+Alt+F inserts a note, Ctrl+Alt+Shift+F jumps between a reference and its note. Default on. */
+    readonly keys?: boolean;
+}
+export declare function footnotes(options?: FootnotesOptions): Plugin;

package/dist/footnotes/plugin.js

@@ -0,0 +1,130 @@
+import { createReconciler } from "./reconcile.js";
+function referenceAt(host, doc, id) {
+    const { ops } = host;
+    for (const path of ops.containerPaths(doc)) {
+        if (ops.isNotes(doc.blocks[path[0]]))
+            continue;
+        let offset = 0;
+        for (const node of ops.getContent(doc, path)) {
+            offset += node.type === "text" ? node.text.length : 1;
+            if (node.type === "note" && node.id === id)
+                return { path, offset };
+        }
+    }
+    return undefined;
+}
+function nearby(content, offset) {
+    let at = 0;
+    let found;
+    for (const node of content) {
+        const next = at + (node.type === "text" ? node.text.length : 1);
+        if (node.type === "note" && (next === offset || at === offset))
+            found = found ?? node.id;
+        at = next;
+    }
+    return found;
+}
+export function footnotes(options = {}) {
+    return {
+        id: "rathkit.footnotes",
+        api: "1",
+        setup(host) {
+            const { ops } = host;
+            const reconcile = createReconciler(ops);
+            host.normalize(reconcile);
+            const noteOf = (doc, path) => {
+                const block = doc.blocks[path[0]];
+                return block && ops.isNotes(block) && path.length >= 2 ? block.items[path[1]]?.id : undefined;
+            };
+            host.command({
+                name: "footnote.insert", label: "Footnote",
+                run: (ctx) => ctx.apply("footnote", (doc, sel) => {
+                    const here = ops.isCollapsed(sel) ? sel.focus.path : sel.anchor.path;
+                    if (ops.kindAt(doc, here) === "pre" || noteOf(doc, here) !== undefined || ops.isNotes(doc.blocks[here[0]]))
+                        return { doc, selection: sel };
+                    const cleared = ops.deleteSelection(doc, sel);
+                    const pos = cleared.selection.anchor;
+                    if (ops.kindAt(cleared.doc, pos.path) === "pre")
+                        return { doc, selection: sel };
+                    const used = new Set(ops.noteIds(cleared.doc));
+                    let n = used.size + 1;
+                    while (used.has(`n${n}`))
+                        n++;
+                    const id = `n${n}`;
+                    const content = ops.getContent(cleared.doc, pos.path);
+                    const next = ops.normalizeInline([...ops.sliceInline(content, 0, pos.offset), { type: "note", id }, ...ops.sliceInline(content, pos.offset)]);
+                    const placed = reconcile(ops.setContent(cleared.doc, pos.path, next), ops.caret({ path: pos.path, offset: pos.offset + 1 }));
+                    const block = placed.doc.blocks.findIndex((b) => ops.isNotes(b));
+                    const list = placed.doc.blocks[block];
+                    const index = list && ops.isNotes(list) ? list.items.findIndex((item) => item.id === id) : -1;
+                    return index === -1 ? placed : { doc: placed.doc, selection: ops.caret({ path: [block, index], offset: 0 }) };
+                }),
+                state: (snap) => {
+                    const path = snap.selection.focus.path;
+                    return { enabled: ops.kindAt(snap.doc, path) !== "pre" && noteOf(snap.doc, path) === undefined };
+                },
+            });
+            host.command({
+                name: "footnote.goto", label: "Go to footnote",
+                mutates: false,
+                run: (ctx) => {
+                    const snap = ctx.snapshot;
+                    const { path, offset } = snap.selection.focus;
+                    const inNote = noteOf(snap.doc, path);
+                    const id = inNote ?? nearby(ops.getContent(snap.doc, path), offset);
+                    if (id === undefined)
+                        return false;
+                    const target = inNote !== undefined ? referenceAt(host, snap.doc, id) : (() => {
+                        const b = snap.doc.blocks.findIndex((block) => ops.isNotes(block));
+                        const list = snap.doc.blocks[b];
+                        const i = list && ops.isNotes(list) ? list.items.findIndex((item) => item.id === id) : -1;
+                        return i === -1 ? undefined : { path: [b, i], offset: 0 };
+                    })();
+                    if (!target)
+                        return false;
+                    const there = ops.caret({ path: target.path, offset: target.offset });
+                    return ctx.apply("footnote-goto", (doc) => ({ doc, selection: there }));
+                },
+                state: (snap) => {
+                    const { path, offset } = snap.selection.focus;
+                    return { enabled: noteOf(snap.doc, path) !== undefined || nearby(ops.getContent(snap.doc, path), offset) !== undefined };
+                },
+            });
+            host.copyFormat((blocks) => {
+                const wanted = ops.noteIds({ blocks });
+                const list = host.editor.snapshot.doc.blocks.find((b) => ops.isNotes(b));
+                if (wanted.length === 0 || !list || !ops.isNotes(list) || blocks.some((b) => ops.isNotes(b)))
+                    return undefined;
+                const items = wanted.flatMap((id) => list.items.filter((item) => item.id === id));
+                return items.length === 0 ? undefined : { "text/html": ops.exportHtml({ blocks: [...blocks, { ...list, items }] }) };
+            });
+            host.pasteTransform((blocks) => {
+                const pasted = blocks.flatMap((b) => (ops.isNotes(b) ? b.items.map((item) => item.id ?? "") : []));
+                const taken = new Set([...ops.noteIds(host.editor.snapshot.doc), ...ops.noteIds({ blocks })]);
+                const rename = new Map();
+                let n = taken.size;
+                for (const id of pasted) {
+                    if (id === "" || rename.has(id) || !ops.noteIds(host.editor.snapshot.doc).includes(id))
+                        continue;
+                    while (taken.has(`n${++n}`)) { }
+                    taken.add(`n${n}`);
+                    rename.set(id, `n${n}`);
+                }
+                if (rename.size === 0)
+                    return blocks;
+                let doc = { blocks: blocks.map((b) => (ops.isNotes(b) ? { ...b, items: b.items.map((item) => (item.id !== undefined && rename.has(item.id) ? { ...item, id: rename.get(item.id) } : item)) } : b)) };
+                for (const path of ops.containerPaths(doc)) {
+                    const content = ops.getContent(doc, path);
+                    if (content.some((node) => node.type === "note" && rename.has(node.id)))
+                        doc = ops.setContent(doc, path, content.map((node) => (node.type === "note" && rename.has(node.id) ? { type: "note", id: rename.get(node.id) } : node)));
+                }
+                return doc.blocks;
+            });
+            if (options.keys ?? true) {
+                host.keybinding({ key: "Mod-Alt-f", command: "footnote.insert" });
+                host.keybinding({ key: "Mod-Alt-Shift-f", command: "footnote.goto" });
+            }
+            host.ui("toolbar.main", { kind: "button", id: "footnote", command: "footnote.insert", icon: "footnote", group: "insert", order: 4 });
+        },
+    };
+}

package/dist/footnotes/reconcile.d.ts

@@ -0,0 +1,4 @@
+import type { Doc } from "../model.ts";
+import type { Ops } from "../ops.ts";
+import type { EditResult, Selection } from "../path.ts";
+export declare function createReconciler(ops: Ops): (doc: Doc, sel: Selection) => EditResult;