@rathkit/rte-core 0.1.0-alpha.4 → 0.2.0-beta.0

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 { asChildren, 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,14 +275,47 @@ 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);

package/dist/engine.d.ts

@@ -5,8 +5,10 @@ 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 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. */
@@ -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 = {
@@ -69,7 +76,8 @@ export declare class Engine {
     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;
@@ -93,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. */
@@ -149,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 {};

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));
@@ -42,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));
@@ -51,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;
@@ -104,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();
@@ -145,6 +159,9 @@ 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;
@@ -158,6 +175,7 @@ export class Engine {
         if (sameSelection(selection, this.sel))
             return;
         this.sel = selection;
+        this.lastKind = "";
         this.commit({ docChanged: false, selectionChanged: true });
     }
     setPluginState(id, value) {
@@ -172,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;
@@ -205,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() {
@@ -215,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) {
@@ -255,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.`);
@@ -262,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));
@@ -273,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); });
@@ -285,51 +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));
                 });
             },
-            normalize: (normalizer) => {
+            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: (transform) => {
+            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); });
             },
-            copyFormat: (formatter) => {
+            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: (handler) => {
+            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.js

@@ -61,7 +61,7 @@ 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.children[0]?.type === "ul" || item.children[0]?.type === "ol"));
+        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) {

package/dist/html/parse.d.ts

@@ -9,6 +9,12 @@ export interface HText {
     readonly text: string;
 }
 export type HNode = HElement | HText;
-/** Parses markup into nodes. Tag and attribute names are lower-cased and entities in text and values are decoded. */
-export declare function parseHtml(source: string): HNode[];
+/** Deepest nesting read when the caller does not say. */
+export declare const DEFAULT_MAX_DEPTH = 100;
+/**
+ * Parses markup into nodes. Tag and attribute names are lower-cased and entities in text and values are decoded. An element
+ * that would nest deeper than `maxDepth` is left out and what is inside it stays in the deepest element allowed, so the tree is
+ * never deeper than that however the markup is written.
+ */
+export declare function parseHtml(source: string, maxDepth?: number): HNode[];
 export declare function findAll(nodes: readonly HNode[], tag: string, out?: HElement[]): HElement[];

package/dist/html/parse.js

@@ -7,7 +7,8 @@ const BLOCKS_CLOSING_P = new Set([
 ]);
 const TAG_NAME = /[A-Za-z][^\s/>]*/y;
 const ATTRIBUTE = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/y;
-export function parseHtml(source) {
+export const DEFAULT_MAX_DEPTH = 100;
+export function parseHtml(source, maxDepth = DEFAULT_MAX_DEPTH) {
     const root = { type: "el", tag: "#root", attrs: {}, children: [] };
     const stack = [root];
     const top = () => stack[stack.length - 1];
@@ -123,9 +124,12 @@ export function parseHtml(source) {
             closeWithin(new Set(["thead", "tbody", "tfoot"]), new Set(["table"]));
         if (BLOCKS_CLOSING_P.has(tag))
             closeWithin(new Set(["p"]), new Set(["li", "td", "th", "table", "blockquote", "div", "ul", "ol"]));
+        const void_ = VOID.has(tag);
+        if (!void_ && stack.length > maxDepth)
+            continue;
         const el = { type: "el", tag, attrs, children: [] };
         top().children.push(el);
-        if (!VOID.has(tag))
+        if (!void_)
             stack.push(el);
     }
     return root.children;

package/dist/images/plugin.js

@@ -21,7 +21,8 @@ export function images(options = {}) {
                     const checked = url ? checkImageSrc(url) : undefined;
                     return checked ?? reject("unsupported", file.type, file.size);
                 }
-                catch {
+                catch (error) {
+                    host.editor.report({ code: "upload-failed", message: `Uploading an image failed: ${error instanceof Error ? error.message : String(error)}`, error });
                     return reject("upload-failed", file.type, file.size);
                 }
             };

package/dist/images/view.d.ts

@@ -1,6 +1,6 @@
 import type { ViewExtension, ViewHost } from "../plugin.ts";
 /** The attribute on the selected image, for styling. */
-export declare const SELECTED_IMAGE = "data-rk-image-selected";
+export declare const SELECTED_IMAGE = "data-rte-image-selected";
 export declare class ImageSelection {
     private readonly host;
     private marked;

package/dist/images/view.js

@@ -1,5 +1,5 @@
 import { imageSelection, selectedImage } from "../imageselect.js";
-export const SELECTED_IMAGE = "data-rk-image-selected";
+export const SELECTED_IMAGE = "data-rte-image-selected";
 const MIN = 16;
 export class ImageSelection {
     host;
@@ -40,7 +40,7 @@ export class ImageSelection {
         return el instanceof HTMLImageElement ? el : undefined;
     }
     update() {
-        const img = this.find();
+        const img = this.engine.readOnly ? undefined : this.find();
         if (img === this.marked) {
             this.place();
             return;
@@ -60,7 +60,7 @@ export class ImageSelection {
         }
         if (!this.handle) {
             const handle = document.createElement("div");
-            handle.setAttribute("data-rk-resize-handle", "");
+            handle.setAttribute("data-rte-resize-handle", "");
             handle.style.cssText = "position:fixed;z-index:2147483646;width:12px;height:12px;background:#17408b;border:2px solid #fff;border-radius:3px;cursor:nwse-resize;touch-action:none;box-sizing:border-box";
             handle.addEventListener("pointerdown", (e) => this.start(e));
             document.body.appendChild(handle);
@@ -80,7 +80,7 @@ export class ImageSelection {
         event.preventDefault();
         const box = img.getBoundingClientRect();
         const guide = document.createElement("div");
-        guide.setAttribute("data-rk-resize-line", "");
+        guide.setAttribute("data-rte-resize-line", "");
         guide.style.cssText = `position:fixed;z-index:2147483645;pointer-events:none;border:2px dashed #17408b;left:${box.left}px;top:${box.top}px;width:${box.width}px;height:${box.height}px;box-sizing:border-box`;
         document.body.appendChild(guide);
         this.drag = { startX: event.clientX, startWidth: box.width, width: box.width, guide };

package/dist/import.d.ts

@@ -49,8 +49,24 @@ export interface ImportOptions {
     readonly linkSchemes?: readonly string[];
     /** Keep empty paragraphs. Content that is loaded keeps them; pasted content does not. */
     readonly keepEmptyBlocks?: boolean;
-    /** Largest `data:` image address, in characters. */
+    /** Largest `data:` image address, in characters. 0 refuses every `data:` image. Default 12 million. */
     readonly maxDataImageLength?: number;
+    /** Longest markup read, in characters. Longer markup is refused whole: nothing is read, `onLimit` is told. Default 50 million. */
+    readonly maxInputLength?: number;
+    /** Keep an image whose address is relative (`a.png`, `/a.png`). Default true; pasting turns it off (see `pasteRelativeImages`). */
+    readonly relativeImages?: boolean;
+    /** Keep relative image addresses when pasting. Default false: a pasted `/path` would be fetched from the page's own origin. */
+    readonly pasteRelativeImages?: boolean;
+    /** Deepest element nesting read; deeper elements are left out and their content kept. Default 100. */
+    readonly maxDepth?: number;
+    /** Told when reading failed for a reason in the reader or a recognizer: the content is then left out and nothing is thrown. */
+    readonly onError?: (error: unknown) => void;
+    /** Told when markup was refused for being longer than `maxInputLength`. */
+    readonly onLimit?: (info: {
+        readonly limit: "maxInputLength";
+        readonly max: number;
+        readonly length: number;
+    }) => void;
 }
 export declare function parseStyle(style: string | undefined): Map<string, string>;
 /** Returns the address when its scheme is allowed, otherwise undefined. Obfuscation with spaces, tabs or entities does not help. */
@@ -62,4 +78,4 @@ export declare function importHtml(html: string, options?: ImportOptions): Doc;
 export declare function importText(value: string): Block[];
 export { decodeEntities };
 /** Checks an image address the same way the importer does: remote, or a raster image whose bytes match its type. */
-export declare const checkImageSrc: (src: string, maxDataLength?: number, sanitizeSvg?: ImportOptions["sanitizeSvg"]) => string | undefined;
+export declare const checkImageSrc: (src: string, maxDataLength?: number, sanitizeSvg?: ImportOptions["sanitizeSvg"], relative?: boolean) => string | undefined;