@hachej/boring-ui-kit 0.1.111 → 0.2.0

package/dist/markdown-icons.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Toolbar icons for the Markdown editor, as inline SVG so the package needs no icon dependency.
+// Path data is from Lucide (https://lucide.dev, ISC license), 24x24 outline icons.
+import { createElement } from 'react';
+const ICONS = {
+    Bold: [["path", { "d": "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8" }]],
+    Italic: [["line", { "x1": "19", "x2": "10", "y1": "4", "y2": "4" }], ["line", { "x1": "14", "x2": "5", "y1": "20", "y2": "20" }], ["line", { "x1": "15", "x2": "9", "y1": "4", "y2": "20" }]],
+    Strike: [["path", { "d": "M16 4H9a3 3 0 0 0-2.83 4" }], ["path", { "d": "M14 12a4 4 0 0 1 0 8H6" }], ["line", { "x1": "4", "x2": "20", "y1": "12", "y2": "12" }]],
+    Heading1: [["path", { "d": "M4 12h8" }], ["path", { "d": "M4 18V6" }], ["path", { "d": "M12 18V6" }], ["path", { "d": "m17 12 3-2v8" }]],
+    Heading2: [["path", { "d": "M4 12h8" }], ["path", { "d": "M4 18V6" }], ["path", { "d": "M12 18V6" }], ["path", { "d": "M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1" }]],
+    Heading3: [["path", { "d": "M4 12h8" }], ["path", { "d": "M4 18V6" }], ["path", { "d": "M12 18V6" }], ["path", { "d": "M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2" }], ["path", { "d": "M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2" }]],
+    BulletList: [["path", { "d": "M3 5h.01" }], ["path", { "d": "M3 12h.01" }], ["path", { "d": "M3 19h.01" }], ["path", { "d": "M8 5h13" }], ["path", { "d": "M8 12h13" }], ["path", { "d": "M8 19h13" }]],
+    OrderedList: [["path", { "d": "M11 5h10" }], ["path", { "d": "M11 12h10" }], ["path", { "d": "M11 19h10" }], ["path", { "d": "M4 4h1v5" }], ["path", { "d": "M4 9h2" }], ["path", { "d": "M6.5 20H3.4c0-1 2.6-1.925 2.6-3.5a1.5 1.5 0 0 0-2.6-1.02" }]],
+    TaskList: [["path", { "d": "M13 5h8" }], ["path", { "d": "M13 12h8" }], ["path", { "d": "M13 19h8" }], ["path", { "d": "m3 17 2 2 4-4" }], ["rect", { "x": "3", "y": "4", "width": "6", "height": "6", "rx": "1" }]],
+    Quote: [["path", { "d": "M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z" }], ["path", { "d": "M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z" }]],
+    Code: [["path", { "d": "m16 18 6-6-6-6" }], ["path", { "d": "m8 6-6 6 6 6" }]],
+    CodeBlock: [["path", { "d": "m10 9-3 3 3 3" }], ["path", { "d": "m14 15 3-3-3-3" }], ["rect", { "x": "3", "y": "3", "width": "18", "height": "18", "rx": "2" }]],
+    Link: [["path", { "d": "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" }], ["path", { "d": "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" }]],
+    Unlink: [["path", { "d": "m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71" }], ["path", { "d": "m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71" }], ["line", { "x1": "8", "x2": "8", "y1": "2", "y2": "5" }], ["line", { "x1": "2", "x2": "5", "y1": "8", "y2": "8" }], ["line", { "x1": "16", "x2": "16", "y1": "19", "y2": "22" }], ["line", { "x1": "19", "x2": "22", "y1": "16", "y2": "16" }]],
+    Highlight: [["path", { "d": "m9 11-6 6v3h9l3-3" }], ["path", { "d": "m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4" }]],
+    Rule: [["path", { "d": "M5 12h14" }]],
+    Table: [["path", { "d": "M3 9h18" }], ["path", { "d": "M9 3v18" }], ["rect", { "x": "3", "y": "3", "width": "18", "height": "18", "rx": "2" }]],
+    Rows: [["path", { "d": "M14 10h2" }], ["path", { "d": "M15 22v-8" }], ["path", { "d": "M15 2v4" }], ["path", { "d": "M2 10h2" }], ["path", { "d": "M20 10h2" }], ["path", { "d": "M3 19h18" }], ["path", { "d": "M3 22v-6a2 2 135 0 1 2-2h14a2 2 45 0 1 2 2v6" }], ["path", { "d": "M3 2v2a2 2 45 0 0 2 2h14a2 2 135 0 0 2-2V2" }], ["path", { "d": "M8 10h2" }], ["path", { "d": "M9 22v-8" }], ["path", { "d": "M9 2v4" }]],
+    Columns: [["path", { "d": "M14 14v2" }], ["path", { "d": "M14 20v2" }], ["path", { "d": "M14 2v2" }], ["path", { "d": "M14 8v2" }], ["path", { "d": "M2 15h8" }], ["path", { "d": "M2 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H2" }], ["path", { "d": "M2 9h8" }], ["path", { "d": "M22 15h-4" }], ["path", { "d": "M22 3h-2a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2" }], ["path", { "d": "M22 9h-4" }], ["path", { "d": "M5 3v18" }]],
+    Trash: [["path", { "d": "M10 11v6" }], ["path", { "d": "M14 11v6" }], ["path", { "d": "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }], ["path", { "d": "M3 6h18" }], ["path", { "d": "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" }]],
+    Check: [["path", { "d": "M20 6 9 17l-5-5" }]],
+    X: [["path", { "d": "M18 6 6 18" }], ["path", { "d": "m6 6 12 12" }]],
+};
+/** Decorative: the button that holds it carries the accessible name. */
+export function MarkdownIcon({ name }) {
+    return _jsx("svg", { className: "boring-markdown-icon", width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", focusable: "false", children: ICONS[name].map(([tag, attributes], index) => createElement(tag, { key: index, ...attributes })) });
+}

package/dist/markdown-mounted.d.ts

@@ -0,0 +1,63 @@
+import type { Editor } from '@tiptap/core';
+import type { PresentationCommand, ViewerTarget } from './contracts.js';
+import type { MarkdownController } from './markdown.js';
+import type { SaveSelection } from './resources.js';
+export type MarkdownMountedSubject = SaveSelection['target']['subject'] & {
+    readonly mountId: string;
+    readonly projectionId: string;
+    readonly mode: 'rich' | 'source';
+};
+export type MarkdownMountedSelection = {
+    readonly kind: 'rich';
+    readonly anchor: number;
+    readonly head: number;
+} | {
+    readonly kind: 'source';
+    readonly start: number;
+    readonly end: number;
+    readonly direction: 'forward' | 'backward' | 'none';
+};
+export interface MarkdownMountedInspection {
+    readonly selection: SaveSelection;
+    readonly dirty: boolean;
+    readonly headings: readonly {
+        readonly index: number;
+        readonly level: number;
+        readonly text: string;
+    }[];
+    readonly currentSelection: MarkdownMountedSelection;
+    readonly text: string;
+}
+export interface MarkdownMountedTools {
+    readonly getTarget: () => ViewerTarget<MarkdownMountedSubject> | null;
+    readonly inspect: PresentationCommand<{
+        readonly expiresAt: number;
+    }, MarkdownMountedInspection, MarkdownMountedSubject>;
+    readonly select: PresentationCommand<{
+        readonly expiresAt: number;
+        readonly selection: MarkdownMountedSelection;
+    }, void, MarkdownMountedSubject>;
+    readonly revealHeading: PresentationCommand<{
+        readonly expiresAt: number;
+        readonly index: number;
+    }, void, MarkdownMountedSubject>;
+}
+type MountedView = {
+    readonly kind: 'rich';
+    readonly editor: Editor;
+    readonly projectedText: () => string | null;
+} | {
+    readonly kind: 'source';
+    readonly element: () => HTMLTextAreaElement | null;
+};
+export declare function createMountedMarkdownTools({ controller, current, view }: {
+    readonly controller: MarkdownController;
+    readonly current: () => boolean;
+    readonly view: MountedView;
+}): {
+    tools: MarkdownMountedTools;
+    activate: () => void;
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=markdown-mounted.d.ts.map

package/dist/markdown-mounted.js

@@ -0,0 +1,263 @@
+import { TextSelection } from '@tiptap/pm/state';
+import { freeze, sameBase } from './text-buffer.js';
+import { randomUUID } from '@hachej/boring-files/platform';
+const expirySchema = { type: 'integer', minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER };
+const positionSchema = { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
+function expiry(value) {
+    if (!value || typeof value !== 'object' || !('expiresAt' in value) || typeof value.expiresAt !== 'number' || !Number.isSafeInteger(value.expiresAt))
+        throw new TypeError('Command expiry is required');
+    return { expiresAt: value.expiresAt };
+}
+function selectionInput(value) {
+    const deadline = expiry(value);
+    if (!value || typeof value !== 'object' || !('selection' in value) || !value.selection || typeof value.selection !== 'object')
+        throw new TypeError('Selection is required');
+    const selected = value.selection;
+    if ('kind' in selected && selected.kind === 'rich' && 'anchor' in selected && 'head' in selected
+        && typeof selected.anchor === 'number' && Number.isSafeInteger(selected.anchor) && selected.anchor >= 0
+        && typeof selected.head === 'number' && Number.isSafeInteger(selected.head) && selected.head >= 0) {
+        return { ...deadline, selection: { kind: 'rich', anchor: selected.anchor, head: selected.head } };
+    }
+    if ('kind' in selected && selected.kind === 'source' && 'start' in selected && 'end' in selected && 'direction' in selected
+        && typeof selected.start === 'number' && Number.isSafeInteger(selected.start) && selected.start >= 0
+        && typeof selected.end === 'number' && Number.isSafeInteger(selected.end) && selected.end >= selected.start
+        && (selected.direction === 'forward' || selected.direction === 'backward' || selected.direction === 'none')) {
+        return { ...deadline, selection: { kind: 'source', start: selected.start, end: selected.end, direction: selected.direction } };
+    }
+    throw new TypeError('Expected a rich document selection or source UTF-16 selection');
+}
+function headingInput(value) {
+    const deadline = expiry(value);
+    if (!value || typeof value !== 'object' || !('index' in value) || typeof value.index !== 'number' || !Number.isSafeInteger(value.index) || value.index < 0)
+        throw new TypeError('Heading index must be a nonnegative integer');
+    return { ...deadline, index: value.index };
+}
+export function createMountedMarkdownTools({ controller, current, view }) {
+    const mountId = randomUUID();
+    let alive = false, projectionId = randomUUID();
+    let document;
+    const pending = new Set();
+    const element = () => {
+        if (view.kind === 'source')
+            return view.element();
+        if (view.editor.isDestroyed)
+            return null;
+        try {
+            return view.editor.view.dom;
+        }
+        catch {
+            return null;
+        }
+    };
+    const getTarget = () => {
+        if (!alive || !current() || controller.getSnapshot().lifecycle !== 'active' || !element()?.isConnected)
+            return null;
+        const state = controller.getSnapshot();
+        if (view.kind === 'source') {
+            if (view.element()?.value !== state.text)
+                return null;
+        }
+        else {
+            if (view.editor.isDestroyed || view.projectedText() !== state.text)
+                return null;
+            if (document !== view.editor.state.doc) {
+                document = view.editor.state.doc;
+                projectionId = randomUUID();
+            }
+        }
+        const selected = controller.actions.selection().target;
+        return freeze({ ...selected, subject: { ...selected.subject, mountId, projectionId, mode: view.kind } });
+    };
+    const check = (target, expiresAt, signal) => {
+        if (!alive || !current() || controller.getSnapshot().lifecycle !== 'active' || !element()?.isConnected)
+            return { kind: 'unavailable', reason: 'Mounted editor is unavailable' };
+        if (signal?.aborted)
+            return { kind: 'denied', reason: 'Command was cancelled' };
+        if (expiresAt <= Date.now())
+            return { kind: 'stale', reason: 'Command expired' };
+        const selected = getTarget();
+        if (!selected)
+            return { kind: 'stale', reason: 'Mounted editor has not projected the current buffer' };
+        if (selected.instanceId !== target.instanceId || selected.epoch !== target.epoch
+            || selected.subject.mountId !== target.subject.mountId || selected.subject.projectionId !== target.subject.projectionId
+            || selected.subject.mode !== target.subject.mode || selected.subject.scopeId !== target.subject.scopeId
+            || selected.subject.bufferVersion !== target.subject.bufferVersion || !sameBase(selected.subject.base, target.subject.base)) {
+            return { kind: 'stale', reason: 'Mounted command target changed' };
+        }
+        return null;
+    };
+    const headings = () => {
+        const values = [];
+        if (view.kind === 'rich')
+            view.editor.state.doc.descendants((node, position) => {
+                if (node.type.name === 'heading')
+                    values.push({ index: values.length, level: Number(node.attrs['level']), text: node.textContent, position });
+            });
+        return values;
+    };
+    const applySelection = (target, expiresAt, selected, signal) => {
+        const refused = check(target, expiresAt, signal);
+        if (refused)
+            return refused;
+        if (selected.kind !== view.kind)
+            return { kind: 'denied', reason: 'Selection coordinates belong to another editor mode' };
+        if (view.kind === 'source' && selected.kind === 'source') {
+            const input = view.element();
+            if (!input)
+                return { kind: 'unavailable', reason: 'Source editor is unavailable' };
+            if (selected.end > input.value.length)
+                return { kind: 'denied', reason: 'Selection is outside the source buffer' };
+            input.focus({ preventScroll: true });
+            const changed = check(target, expiresAt, signal);
+            if (changed)
+                return changed;
+            input.setSelectionRange(selected.start, selected.end, selected.direction);
+            const after = check(target, expiresAt, signal);
+            if (after)
+                return after;
+            const root = input.getRootNode();
+            if (!('activeElement' in root) || root.activeElement !== input || input.selectionStart !== selected.start || input.selectionEnd !== selected.end
+                || selected.start !== selected.end && input.selectionDirection !== selected.direction)
+                return { kind: 'unavailable', reason: 'Source selection was not applied' };
+        }
+        else if (view.kind === 'rich' && selected.kind === 'rich') {
+            const editor = view.editor, doc = editor.state.doc;
+            if (selected.anchor > doc.content.size || selected.head > doc.content.size
+                || !doc.resolve(selected.anchor).parent.inlineContent || !doc.resolve(selected.head).parent.inlineContent)
+                return { kind: 'denied', reason: 'Selection must address document text' };
+            editor.view.dom.focus({ preventScroll: true });
+            const moved = check(target, expiresAt, signal);
+            if (moved)
+                return moved;
+            const domSelection = editor.view.dom.ownerDocument.getSelection();
+            if (!domSelection)
+                return { kind: 'unavailable', reason: 'Browser selection is unavailable' };
+            const anchor = editor.view.domAtPos(selected.anchor);
+            domSelection.collapse(anchor.node, anchor.offset);
+            const selectedDom = check(target, expiresAt, signal);
+            if (selectedDom)
+                return selectedDom;
+            editor.view.dispatch(editor.state.tr.setSelection(TextSelection.create(editor.state.doc, selected.anchor, selected.head)));
+            const changed = check(target, expiresAt, signal);
+            if (changed)
+                return changed;
+            editor.view.focus();
+            const focused = check(target, expiresAt, signal);
+            if (focused)
+                return focused;
+            editor.view.dispatch(editor.state.tr.scrollIntoView());
+            const after = check(target, expiresAt, signal);
+            if (after)
+                return after;
+            if (!editor.view.hasFocus() || editor.state.selection.anchor !== selected.anchor || editor.state.selection.head !== selected.head
+                || !domSelection.anchorNode || !domSelection.focusNode || !editor.view.dom.contains(domSelection.anchorNode) || !editor.view.dom.contains(domSelection.focusNode)
+                || editor.view.posAtDOM(domSelection.anchorNode, domSelection.anchorOffset) !== selected.anchor
+                || editor.view.posAtDOM(domSelection.focusNode, domSelection.focusOffset) !== selected.head)
+                return { kind: 'unavailable', reason: 'Rich selection was not applied' };
+        }
+        return { kind: 'applied', value: undefined };
+    };
+    const schedule = (target, expiresAt, selected, signal) => {
+        const refused = check(target, expiresAt, signal);
+        if (refused)
+            return Promise.resolve(refused);
+        const window = element()?.ownerDocument.defaultView;
+        if (!window)
+            return Promise.resolve({ kind: 'unavailable', reason: 'Editor window is unavailable' });
+        return new Promise(resolve => {
+            let frame = 0, timer, settled = false;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                window.cancelAnimationFrame(frame);
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', abort);
+                pending.delete(finish);
+                resolve(result);
+            };
+            const abort = () => finish({ kind: 'denied', reason: 'Command was cancelled' });
+            const expire = () => {
+                const left = expiresAt - Date.now();
+                if (left <= 0)
+                    finish({ kind: 'stale', reason: 'Command expired' });
+                else
+                    timer = setTimeout(expire, Math.min(left, 2147483647));
+            };
+            pending.add(finish);
+            signal?.addEventListener('abort', abort, { once: true });
+            expire();
+            if (settled)
+                return;
+            try {
+                frame = window.requestAnimationFrame(() => {
+                    if (settled)
+                        return;
+                    try {
+                        finish(applySelection(target, expiresAt, selected, signal));
+                    }
+                    catch {
+                        finish(check(target, expiresAt, signal) ?? { kind: 'unavailable', reason: 'Browser selection failed' });
+                    }
+                });
+            }
+            catch {
+                finish({ kind: 'unavailable', reason: 'Editor frame is unavailable' });
+            }
+            if (signal?.aborted)
+                abort();
+        });
+    };
+    const tools = {
+        getTarget,
+        inspect: {
+            name: 'inspect_mounted_markdown',
+            input: { jsonSchema: { type: 'object', properties: { expiresAt: expirySchema }, required: ['expiresAt'] }, parse: expiry },
+            invoke: async (target, input, signal) => {
+                const captured = structuredClone(target), { expiresAt } = expiry(input), refused = check(captured, expiresAt, signal);
+                if (refused)
+                    return refused;
+                let currentSelection, text;
+                if (view.kind === 'source') {
+                    const input = view.element();
+                    if (!input)
+                        return { kind: 'unavailable', reason: 'Source editor is unavailable' };
+                    currentSelection = { kind: 'source', start: input.selectionStart, end: input.selectionEnd, direction: input.selectionDirection };
+                    text = input.value.slice(input.selectionStart, input.selectionEnd);
+                }
+                else {
+                    const selected = view.editor.state.selection;
+                    currentSelection = { kind: 'rich', anchor: selected.anchor, head: selected.head };
+                    text = view.editor.state.doc.textBetween(selected.from, selected.to, '\n');
+                }
+                return { kind: 'applied', value: freeze({ selection: controller.actions.selection(), dirty: controller.getSnapshot().dirty, headings: headings().map(({ index, level, text }) => ({ index, level, text })), currentSelection, text }) };
+            },
+        },
+        select: {
+            name: 'select_mounted_markdown', input: { jsonSchema: { type: 'object', properties: { expiresAt: expirySchema, selection: { oneOf: [
+                                { type: 'object', properties: { kind: { const: 'rich' }, anchor: positionSchema, head: positionSchema }, required: ['kind', 'anchor', 'head'] },
+                                { type: 'object', properties: { kind: { const: 'source' }, start: positionSchema, end: positionSchema, direction: { enum: ['forward', 'backward', 'none'] } }, required: ['kind', 'start', 'end', 'direction'] },
+                            ] } }, required: ['expiresAt', 'selection'] }, parse: selectionInput },
+            invoke: async (target, input, signal) => { const captured = structuredClone(target), parsed = selectionInput(input); return schedule(captured, parsed.expiresAt, parsed.selection, signal); },
+        },
+        revealHeading: {
+            name: 'reveal_markdown_heading', input: { jsonSchema: { type: 'object', properties: { expiresAt: expirySchema, index: positionSchema }, required: ['expiresAt', 'index'] }, parse: headingInput },
+            invoke: async (target, input, signal) => {
+                const captured = structuredClone(target), parsed = headingInput(input), refused = check(captured, parsed.expiresAt, signal);
+                if (refused)
+                    return refused;
+                if (view.kind !== 'rich')
+                    return { kind: 'unavailable', reason: 'Heading navigation requires the rich editor' };
+                const heading = headings()[parsed.index];
+                if (!heading)
+                    return { kind: 'unavailable', reason: 'Heading is not present' };
+                return schedule(captured, parsed.expiresAt, { kind: 'rich', anchor: heading.position + 1, head: heading.position + 1 }, signal);
+            },
+        },
+    };
+    return { tools, activate: () => { alive = true; }, dispose: () => {
+            alive = false;
+            for (const finish of [...pending])
+                finish({ kind: 'unavailable', reason: 'Mounted editor was detached' });
+        } };
+}

package/dist/markdown-parser.d.ts

@@ -0,0 +1,4 @@
+import { marked } from 'marked';
+/** Tiptap expects the callable marked API; keep its mutable options local to one editor. */
+export declare function createMarkdownParser(): typeof marked;
+//# sourceMappingURL=markdown-parser.d.ts.map

package/dist/markdown-parser.js

@@ -0,0 +1,33 @@
+import { Marked, marked } from 'marked';
+/** Tiptap expects the callable marked API; keep its mutable options local to one editor. */
+export function createMarkdownParser() {
+    const instance = new Marked({ tokenizer: { html: () => undefined, tag: () => undefined } });
+    // marked HTML-escapes the text of inline tokens (`&` becomes `&`); the editor holds plain text, so decode it again or a
+    // serialised document would not match what was written.
+    const plain = (text) => text.replace(/&(?:amp|lt|gt|quot|#39);/g, entity => ({ '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&#39;': "'" })[entity] ?? entity);
+    const decode = (tokens) => {
+        marked.walkTokens(tokens, token => {
+            if ((token.type === 'text' || token.type === 'escape' || token.type === 'codespan') && !('tokens' in token && token.tokens))
+                token.text = plain(token.text);
+        });
+        return tokens;
+    };
+    const parser = Object.assign(instance.parse, marked);
+    parser.parse = parser;
+    parser.defaults = instance.defaults;
+    parser.lexer = (source, options) => decode(options ? marked.Lexer.lex(source, options) : marked.Lexer.lex(source, instance.defaults));
+    parser.parseInline = instance.parseInline;
+    parser.walkTokens = instance.walkTokens.bind(instance);
+    parser.use = (...extensions) => {
+        instance.use(...extensions);
+        parser.defaults = instance.defaults;
+        return parser;
+    };
+    parser.setOptions = options => {
+        instance.setOptions(options);
+        parser.defaults = instance.defaults;
+        return parser;
+    };
+    parser.options = parser.setOptions;
+    return parser;
+}

package/dist/markdown-proposal-diff.d.ts

@@ -0,0 +1,5 @@
+import type { MarkdownProposal } from './markdown.js';
+export declare function MarkdownProposalDiff({ proposal }: {
+    readonly proposal: MarkdownProposal;
+}): import("react").JSX.Element;
+//# sourceMappingURL=markdown-proposal-diff.d.ts.map

package/dist/markdown-proposal-diff.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+const maxMatrixCells = 250_000;
+const contextLines = 2;
+function lineAt(values, index) {
+    const value = values[index];
+    if (value === undefined)
+        throw new RangeError('Line index is outside the comparison');
+    return value;
+}
+function scoreAt(values, index) {
+    const value = values[index];
+    if (value === undefined)
+        throw new RangeError('Comparison index is outside the matrix');
+    return value;
+}
+function lines(text) {
+    const result = [];
+    let start = 0;
+    for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === 10) {
+            result.push(text.slice(start, index + 1));
+            start = index + 1;
+        }
+    }
+    if (start < text.length)
+        result.push(text.slice(start));
+    return result;
+}
+function review(before, after) {
+    const left = lines(before), right = lines(after);
+    let start = 0, endLeft = left.length, endRight = right.length;
+    while (start < endLeft && start < endRight && left[start] === right[start])
+        start++;
+    while (endLeft > start && endRight > start && left[endLeft - 1] === right[endRight - 1]) {
+        endLeft--;
+        endRight--;
+    }
+    const result = left.slice(0, start).map(value => ({ kind: 'same', value }));
+    const middleLeft = endLeft - start, middleRight = endRight - start;
+    const fallback = middleLeft > 0 && middleRight > 0 && middleLeft + 1 > Math.floor(maxMatrixCells / (middleRight + 1));
+    if (fallback || middleLeft === 0 || middleRight === 0) {
+        for (let index = start; index < endLeft; index++)
+            result.push({ kind: 'remove', value: lineAt(left, index) });
+        for (let index = start; index < endRight; index++)
+            result.push({ kind: 'add', value: lineAt(right, index) });
+    }
+    else {
+        const width = middleRight + 1;
+        const matches = new Uint32Array((middleLeft + 1) * width);
+        for (let leftIndex = middleLeft - 1; leftIndex >= 0; leftIndex--) {
+            for (let rightIndex = middleRight - 1; rightIndex >= 0; rightIndex--) {
+                const offset = leftIndex * width + rightIndex;
+                matches[offset] = lineAt(left, start + leftIndex) === lineAt(right, start + rightIndex)
+                    ? scoreAt(matches, offset + width + 1) + 1
+                    : Math.max(scoreAt(matches, offset + width), scoreAt(matches, offset + 1));
+            }
+        }
+        let leftIndex = 0, rightIndex = 0;
+        while (leftIndex < middleLeft || rightIndex < middleRight) {
+            if (leftIndex < middleLeft && rightIndex < middleRight && lineAt(left, start + leftIndex) === lineAt(right, start + rightIndex)) {
+                result.push({ kind: 'same', value: lineAt(left, start + leftIndex) });
+                leftIndex++;
+                rightIndex++;
+            }
+            else if (leftIndex < middleLeft && (rightIndex === middleRight
+                || scoreAt(matches, (leftIndex + 1) * width + rightIndex) >= scoreAt(matches, leftIndex * width + rightIndex + 1))) {
+                result.push({ kind: 'remove', value: lineAt(left, start + leftIndex) });
+                leftIndex++;
+            }
+            else {
+                result.push({ kind: 'add', value: lineAt(right, start + rightIndex) });
+                rightIndex++;
+            }
+        }
+    }
+    for (let index = endLeft; index < left.length; index++)
+        result.push({ kind: 'same', value: lineAt(left, index) });
+    return { lines: result, fallback };
+}
+function entries(diff) {
+    const visible = new Set();
+    for (let index = 0; index < diff.length; index++) {
+        if (diff[index]?.kind === 'same')
+            continue;
+        for (let nearby = Math.max(0, index - contextLines); nearby <= Math.min(diff.length - 1, index + contextLines); nearby++)
+            visible.add(nearby);
+    }
+    const result = [];
+    for (let index = 0; index < diff.length;) {
+        const line = diff[index];
+        if (line?.kind !== 'same' || visible.has(index)) {
+            if (line)
+                result.push(line);
+            index++;
+            continue;
+        }
+        const start = index;
+        while (index < diff.length && diff[index]?.kind === 'same' && !visible.has(index))
+            index++;
+        result.push({ kind: 'fold', index: start, lines: diff.slice(start, index) });
+    }
+    return result;
+}
+function DiffRow({ line }) {
+    const terminated = line.value.endsWith('\n');
+    const display = terminated ? line.value.slice(0, -1) : line.value;
+    return _jsxs("div", { "data-diff": line.kind, "data-line-ending": terminated ? 'lf' : 'none', children: [_jsx("span", { children: line.kind === 'add' ? '+ ' : line.kind === 'remove' ? '- ' : '  ' }), _jsx("span", { "data-diff-text": "", children: display }), line.kind !== 'same' && line.value.endsWith('\r\n') && _jsx("span", { "data-diff-crlf": "", children: " CRLF line ending" }), !terminated && _jsx("span", { "data-diff-no-newline": "", children: " No newline at end" })] });
+}
+export function MarkdownProposalDiff({ proposal }) {
+    const diff = useMemo(() => review(proposal.before, proposal.after), [proposal.before, proposal.after]);
+    const shown = useMemo(() => entries(diff.lines), [diff]);
+    const [expanded, setExpanded] = useState(() => new Set());
+    return _jsxs("div", { "data-boring": "proposal-diff", role: "group", "aria-label": "Proposed line changes", children: [diff.fallback && _jsx("p", { role: "status", "data-diff-fallback": "", children: "Detailed line alignment unavailable; showing changed block." }), proposal.before === proposal.after && _jsx("p", { children: "No text changes" }), _jsx("div", { style: { overflowX: 'auto', whiteSpace: 'pre-wrap' }, children: shown.map((entry, index) => entry.kind === 'fold' ? _jsxs("div", { children: [_jsxs("button", { type: "button", "data-diff-fold": "", "aria-expanded": expanded.has(entry.index), onClick: () => setExpanded(current => {
+                                const next = new Set(current);
+                                if (next.has(entry.index))
+                                    next.delete(entry.index);
+                                else
+                                    next.add(entry.index);
+                                return next;
+                            }), children: [expanded.has(entry.index) ? 'Hide' : 'Show', " ", entry.lines.length, " unchanged lines"] }), expanded.has(entry.index) && entry.lines.map((line, lineIndex) => _jsx(DiffRow, { line: line }, lineIndex))] }, `fold-${entry.index}`) : _jsx(DiffRow, { line: entry }, `line-${index}`)) })] });
+}

package/dist/markdown-safety.d.ts

@@ -0,0 +1,21 @@
+export type MarkdownRichSafety = {
+    readonly safe: true;
+} | {
+    readonly safe: false;
+    readonly reasons: readonly string[];
+};
+/** Blank-line runs outside fenced code collapse to one blank line, and the ends are trimmed: the only whitespace the rich editor may normalise. */
+export declare function normalizeMarkdownWhitespace(text: string): string;
+/** What follows the last visible character, so a rich edit keeps the document's own final newline. */
+export declare function trailingWhitespace(text: string): string;
+/** The text a rich edit publishes: the serialised document, whitespace normalised, with the original's trailing newline. */
+export declare function finishRichMarkdown(serialized: string, previous: string): string;
+/**
+ * Decides whether the rich editor can open and edit `text` without changing anything but what the person edits: the text is
+ * parsed into the editor's document and serialised back without any edit, and must equal the original apart from blank-line runs and
+ * the ends. Named constructs the editor cannot hold (front matter, raw HTML, footnotes, reference links, CRLF) are reported as the
+ * reason. Without a DOM only the named constructs can be checked.
+ */
+export declare function checkMarkdownRichSafety(text: string): MarkdownRichSafety;
+export declare function describeUnsafe(safety: MarkdownRichSafety): string;
+//# sourceMappingURL=markdown-safety.d.ts.map