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

package/dist/dom/view.js

@@ -1,15 +1,13 @@
 import { createEngine } from "../core.js";
-import { caret, clampPos, deleteBackward, deleteForward, deleteSelection, deleteToEdge, deleteWord, extractSelection, insertBlocks, insertLineBreak, insertText, isCollapsed, moveSelection, selectedText, splitBlock, transposeChars, } from "../edit.js";
+import { caret, clampPos, deleteBackward, deleteForward, deleteSelection, deleteToEdge, deleteWord, extractSelection, insertBlocks, insertLineBreak, endAtBlockEnd, insertText, isCollapsed, moveSelection, selectedText, splitBlock, transposeChars, } from "../edit.js";
 import { exportHtml } from "../export.js";
+import { ops } from "../ops.js";
 import { importBlocks, importHtml } from "../import.js";
 import { inlineLength } from "../model.js";
 import { pasteBlocks } from "../paste.js";
-import { cellChain, getContent, setContent } from "../path.js";
+import { cellChain, containerPaths, getContent, pathKey, setContent } from "../path.js";
 import { tableFromText } from "../tablefill.js";
 import { imageSelection } from "../imageselect.js";
-import { ImageSelection } from "./imageview.js";
-import { TableGrips } from "./tablegrips.js";
-import { CellMarks, installColumnResize } from "./tableview.js";
 import { containerAt, createRenderCache, domFromPos, posFromDom, renderDoc } from "./render.js";
 const INPUT_COMMANDS = {
     formatSubscript: ["format.subscript"], formatSuperscript: ["format.superscript"],
@@ -25,6 +23,10 @@ export class Editor {
     engine;
     composing = false;
     reading = false;
+    userReadOnly = false;
+    isDisabled = false;
+    ownTabindex = false;
+    savedTabindex = null;
     loadRemoteImages;
     unhandled;
     dragSource = null;
@@ -43,30 +45,44 @@ export class Editor {
         }
     });
     cleanups = [];
-    cellMarks;
-    imageSelection;
-    tableGrips;
+    changeListeners = new Set();
+    replacing = false;
+    resyncs = new Set();
+    viewHost;
     constructor(options) {
         this.element = options.element;
         this.loadRemoteImages = options.loadRemoteImages ?? false;
         this.unhandled = options.onUnhandledInput;
         this.engine = createEngine({
-            readOnly: options.readOnly ?? false,
+            readOnly: (options.readOnly ?? false) || (options.disabled ?? false),
             beforeAccess: () => this.readSelection(),
             focus: () => this.element.focus(),
+            ...(options.content ? { content: options.content } : {}),
+            ...(options.onWarning ? { onWarning: options.onWarning } : {}),
             ...(options.maxLength !== undefined ? { maxLength: options.maxLength } : {}),
             ...(options.onMaxLength ? { onMaxLength: options.onMaxLength } : {}),
         });
-        this.cellMarks = new CellMarks(this.element, this.engine, () => this.observer.takeRecords());
-        this.imageSelection = new ImageSelection(this.element, this.engine, () => this.observer.takeRecords());
-        this.cleanups.push(() => this.imageSelection.destroy());
-        this.tableGrips = new TableGrips(this.element, this.engine);
-        this.cleanups.push(() => this.tableGrips.destroy());
+        this.viewHost = {
+            element: this.element, engine: this.engine, ops,
+            listen: (target, type, handler) => this.listen(target, type, handler),
+            quiet: () => { this.observer.takeRecords(); },
+            onChange: (listener) => { this.changeListeners.add(listener); return () => this.changeListeners.delete(listener); },
+            posFromDom: (node, offset) => posFromDom(this.element, node, offset),
+            domFromPos: (pos) => domFromPos(this.element, pos),
+        };
         this.engine.pasteHandlers.push(...(options.pasteHandlers ?? []));
-        for (const plugin of options.plugins ?? [])
-            this.engine.use(plugin);
+        for (const plugin of options.plugins ?? []) {
+            try {
+                this.use(plugin);
+            }
+            catch (error) {
+                this.engine.report({ code: "plugin-rejected", plugin: plugin.id, message: `${plugin.id} was not added: ${error instanceof Error ? error.message : String(error)}`, error });
+            }
+        }
         this.engine.setDocument(importHtml(options.html ?? "", this.engine.importOptions));
-        this.element.setAttribute("contenteditable", this.engine.readOnly ? "false" : "true");
+        this.userReadOnly = options.readOnly ?? false;
+        this.isDisabled = options.disabled ?? false;
+        this.applyAccess();
         this.element.setAttribute("role", "textbox");
         this.element.setAttribute("aria-multiline", "true");
         this.element.style.whiteSpace = "pre-wrap";
@@ -82,14 +98,10 @@ export class Editor {
                 this.writeSelection();
             const focusMoved = snapshot.focused !== wasFocused;
             wasFocused = snapshot.focused;
-            if (change.docChanged || change.selectionChanged) {
-                this.cellMarks.update();
-                this.imageSelection.update();
-            }
             if (change.docChanged || change.selectionChanged || focusMoved)
-                this.tableGrips.update();
+                for (const listener of [...this.changeListeners])
+                    listener({ ...change, focusMoved });
         }));
-        installColumnResize(this.element, this.engine, (target, type, handler) => this.listen(target, type, handler), () => this.observer.takeRecords());
         this.listen(this.element, "focusin", () => this.engine.setFocused(true));
         this.listen(this.element, "focusout", () => this.engine.setFocused(false));
         this.listen(this.element, "beforeinput", (e) => this.onBeforeInput(e));
@@ -114,6 +126,15 @@ export class Editor {
         this.listen(this.element, "compositionstart", () => { this.composing = true; });
         this.listen(this.element, "compositionend", () => { this.composing = false; this.reconcileFromDom(); });
         this.listen(document, "selectionchange", () => this.readSelection());
+        this.listen(this.element, "pointerup", () => this.readSelection());
+        this.listen(this.element, "mouseup", (e) => {
+            if (e.detail >= 3) {
+                this.readSelection();
+                const trimmed = endAtBlockEnd(this.engine.document, this.engine.selection);
+                if (trimmed !== this.engine.selection)
+                    this.engine.setSelection(trimmed);
+            }
+        });
         this.observer.observe(this.element, { subtree: true, childList: true, characterData: true, attributes: true });
         if (options.autofocus)
             this.focus();
@@ -134,13 +155,19 @@ export class Editor {
     get canUndo() { return this.engine.canUndo; }
     get canRedo() { return this.engine.canRedo; }
     get readOnly() { return this.engine.readOnly; }
+    get disabled() { return this.isDisabled; }
     get commands() { return this.engine.commands; }
     get ui() { return this.engine.ui; }
     get keymap() { return this.engine.keymap; }
     get snapshot() { return this.engine.snapshot; }
     subscribe = (listener) => this.engine.subscribe(listener);
     select = (selector, onChange, equals) => this.engine.select(selector, onChange, equals);
-    use = (plugin) => this.engine.use(plugin);
+    use = (plugin) => {
+        const remove = this.engine.use(plugin);
+        const stop = this.engine.attempt(plugin.id, "its page part", () => plugin.view?.(this.viewHost), () => undefined);
+        return () => { if (stop)
+            this.engine.attempt(plugin.id, "taking its page part away", stop, undefined); remove(); };
+    };
     getHtml(separator = "") { return exportHtml(this.engine.document, separator); }
     remoteImages() {
         const found = [];
@@ -160,19 +187,98 @@ export class Editor {
     setPlaceholder(text) {
         if (text === "") {
             this.element.removeAttribute("aria-placeholder");
-            this.element.style.removeProperty("--rk-placeholder");
+            this.element.style.removeProperty("--rte-placeholder");
         }
         else {
             this.element.setAttribute("aria-placeholder", text);
-            this.element.style.setProperty("--rk-placeholder", `"${text.replace(/[\\"]/g, "\\$&").replace(/\n/g, "\\A ")}"`);
+            this.element.style.setProperty("--rte-placeholder", `"${text.replace(/[\\"]/g, "\\$&").replace(/\n/g, "\\A ")}"`);
         }
     }
     setHtml(html) {
-        this.engine.setDocument(importHtml(html, this.engine.importOptions));
+        this.replacing = true;
+        try {
+            this.engine.setDocument(importHtml(html, this.engine.importOptions));
+        }
+        finally {
+            this.replacing = false;
+        }
+        for (const resync of this.resyncs)
+            resync();
+    }
+    on(event, listener) {
+        const given = listener;
+        const call = (...args) => this.engine.attempt(undefined, `your ${event} listener`, () => given(...args), undefined, "listener-failed");
+        let last = event === "change" ? this.getHtml() : "";
+        const resync = () => { if (event === "change")
+            last = this.getHtml(); };
+        const handler = (change) => {
+            if (this.replacing)
+                return;
+            if (event === "change") {
+                if (!change.docChanged)
+                    return;
+                const html = this.getHtml();
+                if (html === last)
+                    return;
+                last = html;
+                call(html);
+            }
+            else if (event === "selection") {
+                if (change.selectionChanged)
+                    call(this.selection);
+            }
+            else if (change.focusMoved && this.engine.snapshot.focused === (event === "focus"))
+                call(this);
+        };
+        this.resyncs.add(resync);
+        this.changeListeners.add(handler);
+        return () => { this.resyncs.delete(resync); this.changeListeners.delete(handler); };
     }
     setReadOnly(value) {
-        this.engine.setReadOnly(value);
-        this.element.setAttribute("contenteditable", value ? "false" : "true");
+        this.userReadOnly = value;
+        this.applyAccess();
+    }
+    setDisabled(value) {
+        this.isDisabled = value;
+        this.applyAccess();
+    }
+    applyAccess() {
+        const el = this.element;
+        const off = this.userReadOnly || this.isDisabled;
+        this.engine.setReadOnly(off);
+        el.setAttribute("contenteditable", off ? "false" : "true");
+        if (this.userReadOnly && !this.isDisabled)
+            el.setAttribute("aria-readonly", "true");
+        else
+            el.removeAttribute("aria-readonly");
+        if (this.isDisabled)
+            el.setAttribute("aria-disabled", "true");
+        else
+            el.removeAttribute("aria-disabled");
+        if (off && !this.isDisabled) {
+            if (!el.hasAttribute("tabindex")) {
+                el.setAttribute("tabindex", "0");
+                this.ownTabindex = true;
+            }
+        }
+        else if (this.ownTabindex) {
+            el.removeAttribute("tabindex");
+            this.ownTabindex = false;
+        }
+        if (this.isDisabled) {
+            if (el.hasAttribute("tabindex")) {
+                this.savedTabindex = el.getAttribute("tabindex");
+                el.removeAttribute("tabindex");
+            }
+            if (el.contains(el.ownerDocument.activeElement))
+                el.ownerDocument.activeElement?.blur();
+        }
+        else if (this.savedTabindex !== null) {
+            el.setAttribute("tabindex", this.savedTabindex);
+            this.savedTabindex = null;
+        }
+        for (const listener of [...this.changeListeners])
+            listener({ docChanged: false, selectionChanged: false, focusMoved: false });
     }
     onChange(listener) {
         return this.engine.subscribe(() => listener(this));
@@ -249,13 +355,14 @@ export class Editor {
     draw() {
         renderDoc(this.engine.document, this.element, { loadRemoteImages: this.loadRemoteImages }, this.renderCache);
         const blocks = this.engine.document.blocks;
-        this.element.toggleAttribute("data-rk-empty", blocks.length === 1 && blocks[0]?.type === "p" && blocks[0].content.length === 0);
+        this.element.toggleAttribute("data-rte-empty", blocks.length === 1 && blocks[0]?.type === "p" && blocks[0].content.length === 0);
         this.observer.takeRecords();
         this.writeSelection();
     }
     setSelection(sel) {
         this.engine.setSelection({ anchor: clampPos(this.engine.document, sel.anchor), focus: clampPos(this.engine.document, sel.focus) });
     }
+    fellBack = false;
     readSelection(force = false) {
         if (!force && !this.element.contains(document.activeElement))
             return;
@@ -266,6 +373,7 @@ export class Editor {
             return;
         const first = domSel.rangeCount > 1 ? domSel.getRangeAt(0) : undefined;
         const last = first ? domSel.getRangeAt(domSel.rangeCount - 1) : undefined;
+        this.fellBack = false;
         const anchor = first ? this.posOf(first.startContainer, first.startOffset) : this.posOf(domSel.anchorNode, domSel.anchorOffset);
         const focus = last ? this.posOf(last.endContainer, last.endOffset) : this.posOf(domSel.focusNode, domSel.focusOffset);
         if (!anchor || !focus)
@@ -278,17 +386,33 @@ export class Editor {
         finally {
             this.reading = false;
         }
+        if (this.fellBack && isCollapsed(this.engine.selection))
+            this.writeSelection();
     }
     posOf(node, offset) {
         const direct = node !== this.element ? posFromDom(this.element, node, offset) : null;
         if (direct || !(node instanceof Element))
             return direct;
         const containers = (el) => (el.hasAttribute("data-rte") ? [el, ...el.querySelectorAll("[data-rte]")] : [...el.querySelectorAll("[data-rte]")]);
-        const at = node.children[offset];
-        const first = at ? containers(at)[0] : undefined;
+        this.fellBack = true;
+        let first;
+        for (let i = offset; i < node.children.length && !first; i++)
+            first = containers(node.children[i])[0];
         if (first)
             return posFromDom(this.element, first, 0);
         const all = containers(node);
+        if (all.length === 0 && node !== this.element) {
+            for (let from = node; from && from !== this.element; from = from.parentElement) {
+                for (let next = from.nextElementSibling; next; next = next.nextElementSibling) {
+                    const there = containers(next)[0];
+                    if (there)
+                        return posFromDom(this.element, there, 0);
+                }
+            }
+            const every = [...this.element.querySelectorAll("[data-rte]")];
+            const end = every[every.length - 1];
+            return end ? posFromDom(this.element, end, end.childNodes.length) : null;
+        }
         const last = all[all.length - 1];
         return last ? posFromDom(this.element, last, last.childNodes.length) : null;
     }
@@ -319,7 +443,7 @@ export class Editor {
             return;
         const domSel = document.getSelection();
         const raw = domSel?.focusNode && this.element.contains(domSel.focusNode) ? posFromDom(this.element, domSel.focusNode, domSel.focusOffset) : null;
-        this.apply("type", (doc) => {
+        this.apply("compose", (doc) => {
             const next = setContent(doc, path, first.content);
             return { doc: next, selection: raw ? caret(clampPos(next, raw)) : caret(clampPos(next, this.engine.selection.focus)) };
         });
@@ -494,13 +618,25 @@ export class Editor {
             types: [...clipboard.types],
         });
     }
+    copyFormats() {
+        const blocks = extractSelection(this.engine.document, this.engine.selection);
+        const formats = { "text/html": exportHtml({ blocks }), "text/plain": selectedText(this.engine.document, this.engine.selection) };
+        for (const formatter of this.engine.copyFormatters) {
+            let added;
+            added = formatter(blocks);
+            for (const [type, value] of Object.entries(added ?? {}))
+                if (/^[a-z]+\/[a-z0-9.+-]+$/i.test(type) && typeof value === "string")
+                    formats[type] = value;
+        }
+        return formats;
+    }
     onCopy(event, cut) {
         this.readSelection();
         if (isCollapsed(this.engine.selection) || !event.clipboardData)
             return;
         event.preventDefault();
-        event.clipboardData.setData("text/html", exportHtml({ blocks: extractSelection(this.engine.document, this.engine.selection) }));
-        event.clipboardData.setData("text/plain", selectedText(this.engine.document, this.engine.selection));
+        for (const [type, value] of Object.entries(this.copyFormats()))
+            event.clipboardData.setData(type, value);
         if (cut && !this.engine.readOnly)
             this.apply("cut", deleteSelection);
     }
@@ -515,8 +651,8 @@ export class Editor {
             this.readSelection();
         if (isCollapsed(this.engine.selection) || !event.dataTransfer)
             return;
-        event.dataTransfer.setData("text/html", exportHtml({ blocks: extractSelection(this.engine.document, this.engine.selection) }));
-        event.dataTransfer.setData("text/plain", selectedText(this.engine.document, this.engine.selection));
+        for (const [type, value] of Object.entries(this.copyFormats()))
+            event.dataTransfer.setData(type, value);
         event.dataTransfer.effectAllowed = this.engine.readOnly ? "copy" : "copyMove";
         this.dragSource = this.engine.selection;
     }
@@ -572,7 +708,28 @@ export class Editor {
     onKeyDown(event) {
         if (this.composing || event.isComposing)
             return;
-        if (this.engine.handleKey(event))
+        if (this.engine.handleKey(event)) {
             event.preventDefault();
+            return;
+        }
+        this.keyAtDocumentEdge(event);
+    }
+    keyAtDocumentEdge(event) {
+        if ((event.key !== "Backspace" && event.key !== "Delete") || event.ctrlKey || event.metaKey || event.altKey || event.shiftKey || this.engine.readOnly)
+            return;
+        this.engine.refresh();
+        const sel = this.engine.selection;
+        if (!isCollapsed(sel))
+            return;
+        const paths = containerPaths(this.engine.document);
+        const edge = paths[event.key === "Backspace" ? 0 : paths.length - 1];
+        const here = sel.focus;
+        if (!edge || pathKey(here.path) !== pathKey(edge) || here.offset !== (event.key === "Backspace" ? 0 : inlineLength(getContent(this.engine.document, edge))))
+            return;
+        event.preventDefault();
+        if (event.key === "Backspace")
+            this.apply("delete", (doc, s) => deleteBackward(doc, s, this.engine.behaviors));
+        else
+            this.apply("delete", deleteForward);
     }
 }

package/dist/edit.d.ts

@@ -20,6 +20,12 @@ export declare function insertLineBreak(doc: Doc, sel: Selection): EditResult;
 export declare function splitBlock(doc: Doc, sel: Selection, behaviors?: Behaviors): EditResult;
 export declare function deleteBackward(doc: Doc, sel: Selection, behaviors?: Behaviors): EditResult;
 export declare function deleteForward(doc: Doc, sel: Selection): EditResult;
+/**
+ * A selection of whole blocks that a browser made by running its end on to the start of the next block (a triple click in Chrome and
+ * Safari does this) ends at the end of the last selected block instead, so what is typed or deleted never reaches into the next one.
+ * Anything else is returned as it was.
+ */
+export declare function endAtBlockEnd(doc: Doc, sel: Selection): Selection;
 /** Deletes back to the start of the previous word (or forward to the end of the next). At a block edge it joins blocks like Backspace. */
 export declare function deleteWord(doc: Doc, sel: Selection, direction: "backward" | "forward", behaviors?: Behaviors): EditResult;
 /** Deletes from the caret to the start or end of the block. */

package/dist/edit.js

@@ -1,6 +1,7 @@
 import { inlineLength, inlineText, normalizeInline, } from "./model.js";
+import { setBlockType } from "./blocks.js";
 import { fillTable } from "./tablefill.js";
-import { blockContainers, caret, cellChain, clampPos, comparePath, containerPaths, fixup, getContent, hasContainer, inBlockList, isCollapsed, kindAt, mapBlockList, mapListOf, pathKey, removeEntry, sameCells, setContent, } from "./path.js";
+import { asChildren, blockContainers, caret, cellChain, clampPos, comparePath, containerPaths, fixup, getBlock, getContent, hasContainer, inBlockList, isCollapsed, kindAt, mapBlockList, mapListOf, pathKey, removeEntry, rulePaths, sameCells, setContent, } from "./path.js";
 export { caret, clampPos, isCollapsed };
 export function startOf(doc) {
     return { path: containerPaths(doc)[0] ?? [0], offset: 0 };
@@ -169,6 +170,32 @@ export function insertLineBreak(doc, sel) {
     return { doc: setContent(cleared.doc, pos.path, next), selection: caret({ path: pos.path, offset: pos.offset + 1 }) };
 }
 const behaviorOf = (behaviors, kind) => (kind === "li" || kind === "dt" || kind === "dd" ? behaviors?.[kind] : undefined);
+function quoteParent(doc, path) {
+    if (path.length < 2 || (kindAt(doc, path) !== "p" && kindAt(doc, path) !== "h" && kindAt(doc, path) !== "pre"))
+        return undefined;
+    const quote = path.slice(0, -1);
+    const block = getBlock(doc, quote);
+    return block?.type === "quote" ? { quote, index: path[path.length - 1], count: block.blocks.length } : undefined;
+}
+function liftFromQuote(doc, path, where, sel) {
+    const parent = quoteParent(doc, path);
+    const ordinal = ordinalOf(doc, path);
+    const next = fixup(mapBlockList(doc, parent.quote, (blocks, at) => {
+        const quote = blocks[at];
+        if (quote?.type !== "quote")
+            return blocks;
+        const taken = quote.blocks[parent.index];
+        const left = quote.blocks.filter((_, i) => i !== parent.index);
+        const rest = left.length > 0 ? [{ ...quote, blocks: left }] : [];
+        return [...blocks.slice(0, at), ...(where === "before" ? [taken, ...rest] : [...rest, taken]), ...blocks.slice(at + 1)];
+    }));
+    return { doc: next, selection: caret({ path: containerPaths(next)[ordinal] ?? path, offset: sel.anchor.offset }) };
+}
+const emptyBlock = (doc, path) => (kindAt(doc, path) === "p" || kindAt(doc, path) === "h") && inlineLength(getContent(doc, path)) === 0;
+const isNoteItem = (doc, path) => {
+    const top = doc.blocks[path[0]];
+    return (top?.type === "ol" || top?.type === "ul") && top.notes === true && path.length === 2;
+};
 export function splitBlock(doc, sel, behaviors) {
     const cleared = deleteSelection(doc, sel);
     const pos = cleared.selection.anchor;
@@ -178,8 +205,19 @@ export function splitBlock(doc, sel, behaviors) {
     const before = sliceInline(content, 0, pos.offset);
     const after = sliceInline(content, pos.offset);
     const ordinal = ordinalOf(d, pos.path);
-    if (kind === "pre")
+    if (kind === "pre") {
+        if (pos.offset === inlineLength(content) && pos.offset > 0 && inlineText(content).endsWith("\n")) {
+            const trimmed = setContent(d, pos.path, sliceInline(content, 0, pos.offset - 1));
+            const out = mapBlockList(trimmed, pos.path, (blocks, index) => [...blocks.slice(0, index + 1), { type: "p", content: [] }, ...blocks.slice(index + 1)]);
+            return { doc: out, selection: caret({ path: ordinalToPath(out, ordinal + 1), offset: 0 }) };
+        }
         return insertText(d, cleared.selection, "\n");
+    }
+    if (kind === "p" && content.length === 0) {
+        const parent = quoteParent(d, pos.path);
+        if (parent && parent.index === parent.count - 1)
+            return liftFromQuote(d, pos.path, "after", cleared.selection);
+    }
     if (kind === "li" || kind === "dt" || kind === "dd")
         return behaviorOf(behaviors, kind)?.split?.(d, pos) ?? insertLineBreak(d, cleared.selection);
     const continueAsParagraph = kind === "h" && after.length === 0;
@@ -201,17 +239,33 @@ export function deleteBackward(doc, sel, behaviors) {
     const pos = sel.anchor;
     if (pos.offset > 0)
         return deleteSelection(doc, { anchor: { path: pos.path, offset: pos.offset - 1 }, focus: pos });
+    if (isNoteItem(doc, pos.path))
+        return { doc, selection: sel };
     const leaving = behaviorOf(behaviors, kindAt(doc, pos.path))?.backspaceAtStart?.(doc, pos);
     if (leaving)
         return leaving;
     const ordinal = ordinalOf(doc, pos.path);
+    const rule = lastRule(doc, ordinal);
+    if (rule)
+        return removeRule(doc, rule, ordinal, sel);
+    const kind = kindAt(doc, pos.path);
+    if ((kind === "pre" && (ordinal <= 0 || inlineLength(getContent(doc, pos.path)) > 0)) || (kind === "h" && ordinal <= 0))
+        return setBlockType(doc, sel, { type: "p" });
+    if (quoteParent(doc, pos.path)?.index === 0)
+        return liftFromQuote(doc, pos.path, "before", sel);
     if (ordinal <= 0)
         return { doc, selection: sel };
     const previous = ordinalToPath(doc, ordinal - 1);
     const depths = cellDepths(doc, previous, pos.path);
-    if (depths)
-        return depths[0] > depths[1] ? { doc, selection: caret({ path: previous, offset: inlineLength(getContent(doc, previous)) }) } : { doc, selection: sel };
-    return joinWithPrevious(doc, previous, pos);
+    if (depths) {
+        if (depths[0] <= depths[1])
+            return { doc, selection: sel };
+        if (emptyBlock(doc, pos.path))
+            return joinWithPrevious(doc, previous, pos);
+        return { doc, selection: caret({ path: previous, offset: inlineLength(getContent(doc, previous)) }) };
+    }
+    const joined = joinWithPrevious(doc, previous, pos);
+    return joined.doc === doc ? { doc, selection: caret({ path: previous, offset: inlineLength(getContent(doc, previous)) }) } : joined;
 }
 export function deleteForward(doc, sel) {
     if (!isCollapsed(sel))
@@ -221,18 +275,54 @@ export function deleteForward(doc, sel) {
     if (pos.offset < length)
         return deleteSelection(doc, { anchor: pos, focus: { path: pos.path, offset: pos.offset + 1 } });
     const paths = containerPaths(doc);
-    const next = paths[ordinalOf(doc, pos.path) + 1];
-    if (!next)
+    const ordinal = ordinalOf(doc, pos.path);
+    const rule = firstRule(doc, ordinal + 1);
+    if (rule)
+        return removeRule(doc, rule, ordinal, sel);
+    const next = paths[ordinal + 1];
+    if (!next || isNoteItem(doc, next))
         return { doc, selection: sel };
     const depths = cellDepths(doc, pos.path, next);
-    if (depths)
-        return depths[1] > depths[0] ? { doc, selection: caret({ path: next, offset: 0 }) } : { doc, selection: sel };
+    if (depths) {
+        if (depths[1] <= depths[0])
+            return { doc, selection: sel };
+        if (emptyBlock(doc, pos.path)) {
+            const gone = removeContainer(doc, pos.path);
+            return { doc: gone, selection: caret({ path: containerPaths(gone)[ordinal] ?? next, offset: 0 }) };
+        }
+        return { doc, selection: caret({ path: next, offset: 0 }) };
+    }
     return joinWithPrevious(doc, pos.path, { path: next, offset: 0 });
 }
+export function endAtBlockEnd(doc, sel) {
+    if (isCollapsed(sel))
+        return sel;
+    const forward = comparePath(sel.anchor.path, sel.focus.path) < 0;
+    const [start, end] = forward ? [sel.anchor, sel.focus] : [sel.focus, sel.anchor];
+    if (end.offset !== 0 || start.offset !== 0 || pathKey(start.path) === pathKey(end.path))
+        return sel;
+    const ordinal = ordinalOf(doc, end.path);
+    const previous = ordinal > 0 ? ordinalToPath(doc, ordinal - 1) : undefined;
+    if (!previous || comparePath(previous, start.path) < 0)
+        return sel;
+    const trimmed = { path: previous, offset: inlineLength(getContent(doc, previous)) };
+    return forward ? { anchor: sel.anchor, focus: trimmed } : { anchor: trimmed, focus: sel.focus };
+}
+const lastRule = (doc, ordinal) => rulePaths(doc).filter((r) => r.before === ordinal).pop();
+const firstRule = (doc, ordinal) => rulePaths(doc).find((r) => r.before === ordinal);
+function removeRule(doc, rule, ordinal, sel) {
+    const next = fixup(mapBlockList(doc, rule.path, (blocks, index) => blocks.filter((_, i) => i !== index)));
+    const path = containerPaths(next)[ordinal];
+    const at = sel.anchor;
+    return { doc: next, selection: path ? caret({ path, offset: at.offset }) : sel };
+}
 function joinWithPrevious(doc, into, from) {
     const intoKind = kindAt(doc, into);
     const fromKind = kindAt(doc, from.path);
     const joinable = (k) => k === "p" || k === "h" || k === "li" || k === "dt" || k === "dd";
+    if ((!joinable(intoKind) || !joinable(fromKind)) && inlineLength(getContent(doc, from.path)) === 0 && (fromKind === "p" || fromKind === "h" || fromKind === "pre") && intoKind !== undefined) {
+        return { doc: removeContainer(doc, from.path), selection: caret({ path: into, offset: inlineLength(getContent(doc, into)) }) };
+    }
     if (!joinable(intoKind) || !joinable(fromKind))
         return { doc, selection: caret(from) };
     const head = getContent(doc, into);
@@ -463,8 +553,8 @@ export function extractSelection(doc, sel) {
         const items = list.items.flatMap((item) => {
             const ordinal = n++;
             const content = inRange(ordinal) ? cut(item.content, ordinal) : [];
-            const sublists = item.sublists.map(cropList).filter((l) => l !== undefined);
-            return inRange(ordinal) || sublists.length > 0 ? [{ content, sublists }] : [];
+            const children = asChildren(cropBlocks(item.children));
+            return inRange(ordinal) || children.length > 0 ? [{ content, children, ...(item.checked !== undefined ? { checked: item.checked } : {}), ...(item.id !== undefined ? { id: item.id } : {}) }] : [];
         });
         return items.length > 0 ? { ...list, items } : undefined;
     };

package/dist/engine.d.ts

@@ -5,9 +5,11 @@ import { type Doc, type Mark } from "./model.ts";
 import type { PasteHandler } from "./paste.ts";
 import { type EditResult, type Selection } from "./path.ts";
 import type { ImportOptions } from "./import.ts";
+import { type ContentOptions } from "./policy.ts";
 import { type Counts } from "./stats.ts";
 import { UiRegistry } from "./ui.ts";
-import { type FileHandler, type PasteTransform, type Plugin } from "./plugin.ts";
+import { type Warning } from "./warning.ts";
+import { type CopyFormatter, type FileHandler, type Normalizer, type PasteTransform, type Plugin } from "./plugin.ts";
 export interface EditorSnapshot {
     /** Goes up on every change to the document, selection, read-only or focus state. */
     readonly version: number;
@@ -28,7 +30,7 @@ export interface EngineOptions {
     /** Decides what `Mod` means in key chords. Detected from the environment when not given. */
     readonly platform?: Platform;
     /** Called with warnings meant for developers, such as two plugins claiming one key. Default: the console. */
-    readonly onWarning?: (message: string) => void;
+    readonly onWarning?: (warning: Warning) => void;
     /** The host calls this before the engine reads state it also tracks elsewhere (a DOM selection, say). */
     readonly beforeAccess?: () => void;
     /** Asked to put the keyboard focus in the editor. */
@@ -43,6 +45,11 @@ export interface EngineOptions {
         readonly limit: number;
         readonly wouldBe: number;
     }) => void;
+    /**
+     * What is kept and what is dropped when HTML is read (loading, `setHtml`, pasting): a profile (`strict`, `standard` or `loose`)
+     * and single choices on top of it. See docs/CONTENT-POLICY.md. Default: the `standard` profile.
+     */
+    readonly content?: ContentOptions;
 }
 type Listener = (snapshot: EditorSnapshot, previous: EditorSnapshot) => void;
 type Change = {
@@ -61,11 +68,16 @@ export declare class Engine {
     private readonly textTriggers;
     /** Plugins that change pasted blocks before they go in. */
     readonly pasteTransforms: PasteTransform[];
+    /** Plugins that add formats to what copy, cut and drag write. */
+    readonly copyFormatters: CopyFormatter[];
+    /** Plugins that keep the document consistent after every edit (footnotes keep their notes with their references). */
+    readonly normalizers: Normalizer[];
     /** Plugins that turn pasted and dropped files into blocks. */
     readonly fileHandlers: FileHandler[];
     /** How HTML is imported here: what plugins have added (an SVG cleaner, recognizers). Pass it to the importer. */
     readonly importOptions: {
-        sanitizeSvg?: ImportOptions["sanitizeSvg"];
+        -readonly [K in keyof ImportOptions]: ImportOptions[K];
+    } & {
         recognizers: NonNullable<ImportOptions["recognizers"]>;
     };
     private doc;
@@ -89,6 +101,9 @@ export declare class Engine {
     private readonly focusRequest;
     private readonly maxLength;
     private readonly onMaxLength;
+    /** Reports a problem on the one channel (`onWarning`; the console when there is none). Never throws. */
+    readonly report: (warning: Warning) => void;
+    /** What a plugin says to the developer: reported with the code `plugin-message`. */
     readonly warn: (message: string) => void;
     constructor(options?: EngineOptions);
     /** The current state. A new object after every change, the same object until then. */
@@ -117,6 +132,8 @@ export declare class Engine {
      * `kind` ("type", "delete") share one step. False when nothing changed, or when the editor is read-only.
      */
     apply(kind: string, op: (doc: Doc, sel: Selection) => EditResult): boolean;
+    /** Lets the normalizers put right what an edit left, so the repair is part of the same history step. */
+    private settle;
     /** Sets the selection without making a history step. Nothing happens if it is the selection already. */
     setSelection(selection: Selection): void;
     /** Keeps a plugin's own state with the editor, so commands and interfaces read it from the snapshot. Changes the snapshot; not an undo step. */
@@ -143,7 +160,12 @@ export declare class Engine {
      * first one that takes over, or undefined when none does and the text should be inserted as usual.
      */
     triggerText(typed: string): TriggerResult | undefined;
-    /** Adds a plugin. Returns a function that takes everything it added away again. */
+    /**
+     * Runs `fn` for a plugin or a listener. A throw is reported (`plugin-failed`, or `code`) and `fallback` is used instead; it is never
+     * passed on, so one plugin's failure cannot stop the editor or the plugins after it.
+     */
+    attempt<T>(plugin: string | undefined, where: string, fn: () => T, fallback: (() => T) | undefined, code?: "plugin-failed" | "listener-failed"): T;
+    /** Adds a plugin. Returns a function that takes everything it added away again. A plugin that throws while starting is left out and reported. */
     use(plugin: Plugin): Unsubscribe;
 }
 export {};