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

package/dist/import.js

@@ -1,22 +1,16 @@
 import { decodeEntities } from "./html/entities.js";
 import { parseHtml } from "./html/parse.js";
+import { CONTENT_PROFILES, DATA_IMAGE_SIGNATURES, DEFAULT_LINK_SCHEMES, DROPPED_ELEMENTS, GROUPING_ELEMENTS, IMAGE_SCHEMES } from "./policy.js";
 import { parseLine, SIDES, withSides } from "./cellborder.js";
-import { COLOR_VALUE, COLUMN_WIDTH, MAX_INDENT, ROW_HEIGHT, inlineText, normalizeInline, } from "./model.js";
-const DROP = new Set([
-    "script", "style", "link", "meta", "base", "object", "embed", "iframe", "frame", "frameset", "noscript", "template",
-    "head", "textarea", "input", "select", "option", "button", "canvas", "audio", "video", "applet", "xml",
-]);
-const CONTAINERS = new Set([
-    "div", "section", "article", "header", "footer", "aside", "nav", "figure", "figcaption", "address", "main", "form",
-    "body", "html", "center", "details", "summary", "dd", "dt", "fieldset", "hgroup",
-]);
+import { COLOR_VALUE, COLUMN_WIDTH, MAX_INDENT, NOTE_ID, ROW_HEIGHT, inlineText, normalizeInline, } from "./model.js";
+import { asChildren } from "./path.js";
+import { DEFAULT_MARKER } from "./model.js";
+const DROP = DROPPED_ELEMENTS;
+const CONTAINERS = GROUPING_ELEMENTS;
 const MARK_TAGS = {
     strong: "bold", b: "bold", em: "italic", i: "italic", cite: "italic", dfn: "italic", var: "italic", u: "underline", ins: "underline",
     s: "strike", strike: "strike", del: "strike", code: "code", tt: "code", kbd: "code", samp: "code", sup: "sup", sub: "sub",
 };
-const RASTER = [
-    ["image/png", "iVBORw0KGgo"], ["image/jpeg", "/9j/"], ["image/gif", "R0lGOD"], ["image/webp", "UklGR"], ["image/bmp", "Qk"],
-];
 const COLOR = COLOR_VALUE;
 export function parseStyle(style) {
     const out = new Map();
@@ -76,9 +70,11 @@ function safeImageSrc(raw, settings) {
         if (!match)
             return undefined;
         const body = match[2];
-        return RASTER.some(([, magic]) => body.startsWith(magic)) ? value : undefined;
+        return DATA_IMAGE_SIGNATURES.some(([, magic]) => body.startsWith(magic)) ? value : undefined;
     }
-    return safeUrl(value, new Set(["http", "https"]));
+    if (!settings.relative && !/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(value.replace(INVISIBLE, "")))
+        return undefined;
+    return safeUrl(value, new Set(IMAGE_SCHEMES));
 }
 class Sink {
     blocks = [];
@@ -275,6 +271,12 @@ function inlineOf(nodes, ctx, settings) {
             content.push(...(content.length > 0 ? [{ type: "br" }] : []), ...block.content);
     return normalizeInline(content);
 }
+const NOTE_PREFIX = /^(?:user-content-)?(?:fnref|fn)[-:_]?/i;
+const noteId = (raw, strip) => {
+    const id = strip ? raw?.replace(/^#/, "").replace(NOTE_PREFIX, "").replace(/[^\w-]/g, "") : raw;
+    return id !== undefined && NOTE_ID.test(id) ? id : undefined;
+};
+const hasClass = (el, name) => (el.attrs.class ?? "").split(/\s+/).includes(name);
 function convertElement(el, sink, ctx, settings) {
     const tag = el.tag;
     if (DROP.has(tag) || tag === "title")
@@ -291,7 +293,7 @@ function convertElement(el, sink, ctx, settings) {
                 type: listItem.type,
                 ...(listItem.start !== undefined && listItem.start !== 1 ? { start: listItem.start } : {}),
                 ...(listItem.style !== undefined ? { style: listItem.style } : {}),
-                items: [{ content: normalizeInline(listItem.content), sublists: [], level: listItem.level, listId: listItem.listId }],
+                items: [{ content: normalizeInline(listItem.content), children: [], level: listItem.level, listId: listItem.listId }],
             });
         }
         return;
@@ -304,6 +306,22 @@ function convertElement(el, sink, ctx, settings) {
         sink.flush((content) => ({ type: "h", level, content: withoutBold(content) }), true);
         return;
     }
+    if (tag === "a" && (el.attrs.role === "doc-backlink" || el.attrs["data-footnote-backref"] !== undefined || hasClass(el, "footnote-back") || hasClass(el, "footnote-backref")))
+        return;
+    if ((tag === "sup" && el.attrs["data-note"] !== undefined) || (tag === "a" && (el.attrs.role === "doc-noteref" || el.attrs["data-footnote-ref"] !== undefined || hasClass(el, "footnote-ref")))) {
+        const id = tag === "sup" ? noteId(el.attrs["data-note"], false) : noteId(el.attrs.href, true);
+        if (id !== undefined) {
+            sink.push({ type: "note", id });
+            return;
+        }
+    }
+    if (el.attrs.role === "doc-endnotes" || el.attrs["data-footnotes"] !== undefined || hasClass(el, "footnotes")) {
+        sink.flush();
+        for (const ol of el.tag === "ol" ? [el] : el.children)
+            if (ol.type === "el" && ol.tag === "ol")
+                sink.blocks.push(convertList(ol, ctx, settings, true));
+        return;
+    }
     switch (tag) {
         case "br":
             sink.push({ type: "br" });
@@ -452,18 +470,17 @@ function listStyleOf(el) {
     return style && /^[a-z-]+$/.test(style) && !/^(initial|inherit|unset|revert|none)$/.test(style) ? style : undefined;
 }
 const isCheckbox = (n) => n.type === "el" && n.tag === "input" && (n.attrs.type ?? "").toLowerCase() === "checkbox";
-const blankText = (n) => n.type === "text" && n.text.trim() === "";
 function taskOf(li) {
     const own = (li.attrs["aria-checked"] ?? li.attrs["data-checked"] ?? "").toLowerCase();
     const classes = (li.attrs.class ?? "").toLowerCase().split(/\s+/);
     const fromMarkup = own === "true" || classes.includes("checked") || classes.includes("task-done") ? true : own === "false" || classes.includes("unchecked") ? false : undefined;
     const kids = li.children;
-    const at = kids.findIndex((n) => !blankText(n));
+    const at = kids.findIndex((n) => !isBlank(n));
     const first = at === -1 ? undefined : kids[at];
     if (first && isCheckbox(first))
         return { checked: "checked" in first.attrs, children: [...kids.slice(0, at), ...kids.slice(at + 1)] };
     if (first && first.type === "el" && /^(label|p|span|div)$/.test(first.tag)) {
-        const inner = first.children.findIndex((n) => !blankText(n));
+        const inner = first.children.findIndex((n) => !isBlank(n));
         const box = inner === -1 ? undefined : first.children[inner];
         if (box && isCheckbox(box)) {
             const wrapper = { ...first, children: [...first.children.slice(0, inner), ...first.children.slice(inner + 1)] };
@@ -472,8 +489,10 @@ function taskOf(li) {
     }
     return fromMarkup === undefined ? undefined : { checked: fromMarkup, children: kids };
 }
-function convertList(el, ctx, settings) {
+function convertList(el, ctx, settings, notes = false) {
     const list = { type: el.tag === "ol" ? "ol" : "ul", items: [] };
+    if (notes)
+        list.notes = true;
     const start = el.tag === "ol" && el.attrs.start !== undefined ? Number.parseInt(el.attrs.start, 10) : NaN;
     if (Number.isFinite(start) && start !== 1 && start >= 0 && start < 100000)
         list.start = start;
@@ -483,8 +502,8 @@ function convertList(el, ctx, settings) {
             continue;
         if (child.tag === "ul" || child.tag === "ol") {
             const nested = convertList(child, ctx, settings);
-            const last = list.items[list.items.length - 1] ?? list.items[list.items.push({ content: [], sublists: [] }) - 1];
-            last.sublists.push(nested);
+            const last = list.items[list.items.length - 1] ?? list.items[list.items.push({ content: [], children: [], bare: true }) - 1];
+            last.children.push(nested);
             continue;
         }
         if (child.tag !== "li")
@@ -497,19 +516,34 @@ function convertList(el, ctx, settings) {
         const task = taskOf(child);
         convertNodes(task ? task.children : child.children, inner, ctx, settings);
         inner.flush();
-        const item = { content: [], sublists: [] };
+        const item = { content: [], children: [] };
         if (task)
             item.checked = task.checked;
+        let leading = true;
         for (const block of inner.blocks) {
-            if (block.type === "ul" || block.type === "ol")
-                item.sublists.push(block);
-            else if (block.type === "p" || block.type === "h") {
+            if (leading && (block.type === "p" || block.type === "h")) {
                 if (item.content.length > 0)
                     item.content.push({ type: "br", paragraph: true });
                 item.content.push(...block.content);
+                continue;
             }
+            leading = false;
+            if (isList(block))
+                item.children.push(block);
+            else
+                item.children.push(...asChildren([block]));
         }
         item.content = normalizeInline(item.content);
+        if (notes) {
+            const tail = item.content[item.content.length - 1];
+            if (tail?.type === "text")
+                item.content = normalizeInline([...item.content.slice(0, -1), { ...tail, text: tail.text.trimEnd() }]);
+            const id = noteId(child.attrs["data-note"], false) ?? noteId(child.attrs.id, true);
+            if (id !== undefined)
+                item.id = id;
+        }
+        if (item.content.length === 0 && !task && item.children.length > 0 && /list-style(-type)?\s*:\s*none/i.test(child.attrs.style ?? ""))
+            item.bare = true;
         const level = levelOf(child.attrs["data-aria-level"] ?? child.attrs["aria-level"]);
         if (level !== undefined)
             item.level = level;
@@ -637,7 +671,7 @@ function rowHeights(rowEls, kept) {
     return heights.some((h) => h !== null) ? heights : undefined;
 }
 function columnWidths(table, rows) {
-    const cols = Math.max(0, ...rows.map((row) => row.reduce((sum, cell) => sum + cell.colspan, 0)));
+    const cols = rows.reduce((most, row) => Math.max(most, row.reduce((sum, cell) => sum + cell.colspan, 0)), 0);
     const widths = [];
     const visit = (nodes) => {
         for (const n of nodes) {
@@ -658,7 +692,7 @@ function columnWidths(table, rows) {
         if (firstRow)
             for (const cell of firstRow.children)
                 if (cell.type === "el" && (cell.tag === "td" || cell.tag === "th")) {
-                    const span = Math.max(Number.parseInt(cell.attrs.colspan ?? "1", 10) || 1, 1);
+                    const span = Math.min(Math.max(Number.parseInt(cell.attrs.colspan ?? "1", 10) || 1, 1), 100);
                     if (span === 1)
                         widths.push(widthOf(cell));
                     else
@@ -693,13 +727,12 @@ function padRows(rows) {
                 reach[k] = reach[k] - 1;
         return used;
     });
-    const widest = Math.max(0, ...widths);
+    const widest = widths.reduce((most, w) => Math.max(most, w), 0);
     return rows.map((cells, i) => {
         const missing = widest - widths[i];
         return missing > 0 ? [...cells, ...Array.from({ length: missing }, () => ({ header: false, colspan: 1, rowspan: 1, blocks: [{ type: "p", content: [] }] }))] : cells;
     });
 }
-const DEFAULT_MARKER = (type, depth) => (type === "ol" ? "decimal" : ["disc", "circle", "square"][Math.min(depth, 2)]);
 const isList = (block) => block.type === "ul" || block.type === "ol";
 const hinted = (list) => list.items.length > 0 && list.items.every((item) => item.level !== undefined);
 function finishBlocks(blocks) {
@@ -744,8 +777,8 @@ function nestByLevel(lists) {
                 const fresh = { type: list.type, items: [] };
                 const parent = stack[stack.length - 1];
                 if (parent) {
-                    const host = parent.items[parent.items.length - 1] ?? parent.items[parent.items.push({ content: [], sublists: [] }) - 1];
-                    host.sublists.push(fresh);
+                    const host = parent.items[parent.items.length - 1] ?? parent.items[parent.items.push({ content: [], children: [], bare: true }) - 1];
+                    host.children.push(fresh);
                 }
                 else {
                     result.push(fresh);
@@ -757,15 +790,15 @@ function nestByLevel(lists) {
                 stack.push(fresh);
                 ids.push(item.listId);
             }
-            stack[stack.length - 1].items.push({ content: item.content, sublists: item.sublists, ...(item.checked !== undefined ? { checked: item.checked } : {}) });
+            stack[stack.length - 1].items.push({ content: item.content, children: item.children, ...(item.checked !== undefined ? { checked: item.checked } : {}) });
         }
     }
     return result.map((l) => freezeList(l, 0));
 }
 function freezeList(list, depth) {
-    const items = list.items.map((item) => ({ content: item.content, sublists: item.sublists.map((sub) => freezeList(sub, depth + 1)), ...(item.checked !== undefined ? { checked: item.checked } : {}) }));
+    const items = list.items.map((item) => ({ content: item.content, children: item.children.map((child) => (child.type === "ul" || child.type === "ol" ? freezeList(child, depth + 1) : child)), ...(item.checked !== undefined ? { checked: item.checked } : {}), ...(item.id !== undefined ? { id: item.id } : {}), ...(item.bare ? { bare: true } : {}) }));
     const style = list.style !== undefined && list.style !== DEFAULT_MARKER(list.type, depth) ? list.style : undefined;
-    return { type: list.type, ...(list.start !== undefined ? { start: list.start } : {}), ...(style !== undefined ? { style } : {}), items };
+    return { type: list.type, ...(list.notes ? { notes: true } : {}), ...(list.start !== undefined ? { start: list.start } : {}), ...(style !== undefined ? { style } : {}), items };
 }
 function repairRewrittenSpaces(nodes) {
     return nodes.map((node) => {
@@ -784,17 +817,29 @@ function repairRewrittenSpaces(nodes) {
 export function importBlocks(html, options = {}) {
     const settings = {
         allowStyles: (options.styles ?? "allowlist") === "allowlist",
-        schemes: new Set(options.linkSchemes ?? ["http", "https", "mailto", "tel"]),
+        schemes: new Set(options.linkSchemes ?? DEFAULT_LINK_SCHEMES),
         keepEmpty: options.keepEmptyBlocks ?? false,
-        maxData: options.maxDataImageLength ?? 12_000_000,
+        maxData: options.maxDataImageLength ?? CONTENT_PROFILES.standard.maxDataImageLength,
+        relative: options.relativeImages ?? true,
         svg: options.sanitizeSvg,
         recognizers: options.recognizers ?? [],
     };
-    const sink = new Sink(settings);
-    const tree = parseHtml(html);
-    convertNodes(/-webkit-text-stroke-width/.test(html) ? repairRewrittenSpaces(tree) : tree, sink, { marks: [], inLink: false, pre: false }, settings);
-    sink.flush();
-    return finishBlocks(sink.blocks);
+    const maxInput = options.maxInputLength ?? CONTENT_PROFILES.standard.maxInputLength;
+    if (html.length > maxInput) {
+        options.onLimit?.({ limit: "maxInputLength", max: maxInput, length: html.length });
+        return [];
+    }
+    try {
+        const sink = new Sink(settings);
+        const tree = parseHtml(html, options.maxDepth ?? CONTENT_PROFILES.standard.maxDepth);
+        convertNodes(/-webkit-text-stroke-width/.test(html) ? repairRewrittenSpaces(tree) : tree, sink, { marks: [], inLink: false, pre: false }, settings);
+        sink.flush();
+        return finishBlocks(sink.blocks);
+    }
+    catch (error) {
+        options.onError?.(error);
+        return [];
+    }
 }
 export function importHtml(html, options = {}) {
     const blocks = importBlocks(html, { keepEmptyBlocks: true, ...options });
@@ -817,4 +862,4 @@ export function importText(value) {
 }
 const decodeLineBreaks = (value) => value.replace(/\r\n?|\u2028|\u2029/g, "\n").replace(/^\n+|\n+$/g, "");
 export { decodeEntities };
-export const checkImageSrc = (src, maxDataLength = 12_000_000, sanitizeSvg) => safeImageSrc(src, { maxData: maxDataLength, svg: sanitizeSvg });
+export const checkImageSrc = (src, maxDataLength = 12_000_000, sanitizeSvg, relative = true) => safeImageSrc(src, { maxData: maxDataLength, svg: sanitizeSvg, relative });

package/dist/index.d.ts

@@ -1,9 +1,12 @@
-export declare const PACKAGE_NAME: "@rathkit/rte-core";
 export * from "./model.ts";
 export { checkImageSrc, importBlocks, importHtml, importText, safeUrl, parseStyle, type ImportOptions } from "./import.ts";
+export { WARNING_CODES, type Warning, type WarningCode } from "./warning.ts";
+export { CONTENT_PROFILES, contentPolicy, type ContentLimits, type ContentOptions, type ContentPolicy, type ContentProfile } from "./policy.ts";
 export { exportBlock, exportHtml, exportInline } from "./export.ts";
 export * from "./path.ts";
 export * from "./edit.ts";
+export type { CopyFormatter, Normalizer } from "./plugin.ts";
+export { isNotes, noteIds } from "./notes.ts";
 export { defaultPaste, extractFragment, pasteBlocks, type ClipboardData, type PasteHandler } from "./paste.ts";
 export { decodeBase64, encodeBase64 } from "./base64.ts";
 export { createEngine } from "./core.ts";

package/dist/index.js

@@ -1,9 +1,11 @@
-export const PACKAGE_NAME = "@rathkit/rte-core";
 export * from "./model.js";
 export { checkImageSrc, importBlocks, importHtml, importText, safeUrl, parseStyle } from "./import.js";
+export { WARNING_CODES } from "./warning.js";
+export { CONTENT_PROFILES, contentPolicy } from "./policy.js";
 export { exportBlock, exportHtml, exportInline } from "./export.js";
 export * from "./path.js";
 export * from "./edit.js";
+export { isNotes, noteIds } from "./notes.js";
 export { defaultPaste, extractFragment, pasteBlocks } from "./paste.js";
 export { decodeBase64, encodeBase64 } from "./base64.js";
 export { createEngine } from "./core.js";

package/dist/lists/lists.js

@@ -2,13 +2,28 @@ import { deleteSelection, sliceInline } from "../edit.js";
 import { inlineText, normalizeInline } from "../model.js";
 import { caret, clampPos, containerPaths, selectedContainers, fixup, getBlock, getContent, isCollapsed, kindAt, mapBlockList, pathKey, setContent, } from "../path.js";
 function locateItem(doc, path) {
+    const inList = (list, rest, listBlock, steps) => {
+        const [i, k, ...more] = rest;
+        if (i === undefined)
+            return undefined;
+        if (k === undefined)
+            return { listBlock, item: [...steps, i] };
+        const child = list.items[i]?.children[k];
+        if (!child)
+            return undefined;
+        if (child.type === "ul" || child.type === "ol")
+            return inList(child, more, listBlock, [...steps, i, k]);
+        if (child.type === "quote")
+            return walk(child.blocks, more, [...listBlock, ...steps, i, k]);
+        return undefined;
+    };
     const walk = (blocks, rest, prefix) => {
         const [n, ...more] = rest;
         const block = n === undefined ? undefined : blocks[n];
         if (!block)
             return undefined;
         if (block.type === "ul" || block.type === "ol")
-            return { listBlock: [...prefix, n], item: more };
+            return inList(block, more, [...prefix, n], []);
         if (block.type === "quote")
             return walk(block.blocks, more, [...prefix, n]);
         if (block.type === "table") {
@@ -30,8 +45,8 @@ function listOfItem(doc, path) {
     for (let at = 0;; at += 2) {
         if (steps.length - at === 1)
             return { list, index: steps[at] };
-        const sub = list.items[steps[at]]?.sublists[steps[at + 1]];
-        if (!sub)
+        const sub = list.items[steps[at]]?.children[steps[at + 1]];
+        if (sub?.type !== "ul" && sub?.type !== "ol")
             return undefined;
         list = sub;
     }
@@ -53,21 +68,21 @@ function splitList(list, path, liftChildren) {
     const item = list.items[i];
     const numbering = (count) => (list.type === "ol" ? { start: (list.start ?? 1) + count } : {});
     if (k === undefined) {
-        const placeholder = item.sublists.length > 0 && !liftChildren ? [{ content: [], sublists: item.sublists }] : [];
+        const placeholder = item.children.length > 0 && !liftChildren ? [{ content: [], children: item.children, bare: true }] : [];
         const rest = [...placeholder, ...list.items.slice(i + 1)];
         return {
             before: i > 0 ? { ...list, items: list.items.slice(0, i) } : undefined,
             content: item.content,
-            lifted: liftChildren ? item.sublists : [],
+            lifted: liftChildren ? item.children : [],
             after: rest.length > 0 ? { ...list, ...numbering(i + 1), items: rest } : undefined,
         };
     }
-    const inner = splitList(item.sublists[k], path.slice(2), liftChildren);
-    const keptSublists = [...item.sublists.slice(0, k), ...(inner.before ? [inner.before] : [])];
-    const afterSublists = [...(inner.after ? [inner.after] : []), ...item.sublists.slice(k + 1)];
-    const rest = [...(afterSublists.length > 0 ? [{ content: [], sublists: afterSublists }] : []), ...list.items.slice(i + 1)];
+    const inner = splitList(item.children[k], path.slice(2), liftChildren);
+    const keptSublists = [...item.children.slice(0, k), ...(inner.before ? [inner.before] : [])];
+    const afterSublists = [...(inner.after ? [inner.after] : []), ...item.children.slice(k + 1)];
+    const rest = [...(afterSublists.length > 0 ? [{ content: [], children: afterSublists, bare: true }] : []), ...list.items.slice(i + 1)];
     return {
-        before: { ...list, items: [...list.items.slice(0, i), { content: item.content, sublists: keptSublists }] },
+        before: { ...list, items: [...list.items.slice(0, i), { content: item.content, children: keptSublists }] },
         content: inner.content,
         lifted: inner.lifted,
         after: rest.length > 0 ? { ...list, ...numbering(i + 1), items: rest } : undefined,
@@ -98,7 +113,7 @@ function updateListOf(doc, itemPath, change) {
         if (steps.length === 1)
             return change(list);
         const [i, k] = steps;
-        return { ...list, items: list.items.map((item, idx) => (idx !== i ? item : { ...item, sublists: item.sublists.map((sub, s) => (s === k ? edit(sub, steps.slice(2)) : sub)) })) };
+        return { ...list, items: list.items.map((item, idx) => (idx !== i ? item : { ...item, children: item.children.map((sub, s) => (s === k && (sub.type === "ul" || sub.type === "ol") ? edit(sub, steps.slice(2)) : sub)) })) };
     };
     return replaceBlock(doc, loc.listBlock, [edit(root, loc.item)]);
 }
@@ -179,7 +194,7 @@ export function toggleList(doc, sel, type, options = {}) {
     for (const run of [...runs].reverse()) {
         const first = run[0];
         next = fixup(mapBlockList(next, first, (blocks, index) => {
-            const items = run.map((_, n) => ({ content: blocks[index + n].content, sublists: [] }));
+            const items = run.map((_, n) => ({ content: blocks[index + n].content, children: [] }));
             let list = withOptions({ type, items }, options);
             let from = index;
             let to = index + run.length;
@@ -218,7 +233,7 @@ function mapListAt(doc, itemPath, fn) {
         const [i, k] = steps;
         return {
             ...list,
-            items: list.items.map((item, idx) => idx !== i ? item : { ...item, sublists: item.sublists.flatMap((sub, s) => (s !== k ? [sub] : [edit(sub, steps.slice(2))].filter((x) => x !== undefined))) }),
+            items: list.items.map((item, idx) => idx !== i ? item : { ...item, children: item.children.flatMap((sub, s) => (s !== k || (sub.type !== "ul" && sub.type !== "ol") ? [sub] : [edit(sub, steps.slice(2))].filter((x) => x !== undefined))) }),
         };
     };
     const next = edit(root, loc.item);
@@ -247,16 +262,16 @@ export function indentItems(doc, sel, maxDepth = Number.POSITIVE_INFINITY) {
             const flat = moved;
             const previous = list.items[index - 1];
             const nested = (target) => {
-                const last = target.sublists.at(-1);
-                const sublists = last && last.type === list.type
-                    ? [...target.sublists.slice(0, -1), { ...last, items: [...last.items, ...flat] }]
-                    : [...target.sublists, { type: list.type, items: flat }];
-                return { ...target, sublists };
+                const last = target.children.at(-1);
+                const children = last && last.type === list.type
+                    ? [...target.children.slice(0, -1), { ...last, items: [...last.items, ...flat] }]
+                    : [...target.children, { type: list.type, items: flat }];
+                return { ...target, children };
             };
             const rest = list.items.slice(index + group.length);
             if (previous)
                 return { ...list, items: [...list.items.slice(0, index - 1), nested(previous), ...rest] };
-            return { ...list, items: [nested({ content: [], sublists: [] }), ...rest] };
+            return { ...list, items: [nested({ content: [], children: [], bare: true }), ...rest] };
         });
     }
     return { doc: next, selection: carry(doc, next, sel) };
@@ -271,6 +286,10 @@ export function outdentItems(doc, sel) {
         if (!loc)
             continue;
         if (loc.item.length === 1) {
+            const here = listOfItem(next, path);
+            const held = here?.list.items[here.index];
+            if (held && held.content.length === 0 && held.children.length > 0)
+                continue;
             next = takeOutOfList(next, path, true);
             continue;
         }
@@ -279,16 +298,17 @@ export function outdentItems(doc, sel) {
         const itemIndex = path.at(-1);
         next = mapListAt(next, parentPath, (list, parentIndex) => {
             const parent = list.items[parentIndex];
-            const sub = parent.sublists[sublistIndex];
+            const sub = parent.children[sublistIndex];
             const moved = sub.items[itemIndex];
             const followers = sub.items.slice(itemIndex + 1);
             const keptSub = itemIndex > 0 ? [{ ...sub, items: sub.items.slice(0, itemIndex) }] : [];
             const lifted = {
                 content: moved.content,
-                sublists: [...moved.sublists, ...(followers.length > 0 ? [{ type: sub.type, ...(sub.style !== undefined ? { style: sub.style } : {}), items: followers }] : [])],
+                ...(moved.bare ? { bare: true } : {}),
+                children: [...moved.children, ...(followers.length > 0 ? [{ type: sub.type, ...(sub.style !== undefined ? { style: sub.style } : {}), items: followers }] : [])],
             };
-            const sublists = [...parent.sublists.slice(0, sublistIndex), ...keptSub, ...parent.sublists.slice(sublistIndex + 1)];
-            const items = [...list.items.slice(0, parentIndex), { content: parent.content, sublists }, lifted, ...list.items.slice(parentIndex + 1)];
+            const children = [...parent.children.slice(0, sublistIndex), ...keptSub, ...parent.children.slice(sublistIndex + 1)];
+            const items = [...list.items.slice(0, parentIndex), { content: parent.content, children }, lifted, ...list.items.slice(parentIndex + 1)];
             return { ...list, items };
         });
     }
@@ -340,6 +360,11 @@ export function backspaceAtItemStart(doc, pos) {
     const held = listOfItem(doc, pos.path);
     if (held?.list.items[held.index]?.checked !== undefined)
         return { doc: setChecked(doc, pos.path, undefined), selection: caret(pos) };
+    const only = held?.list.items[held.index];
+    if (only && only.content.length === 0 && only.bare !== true && (only.children[0]?.type === "ul" || only.children[0]?.type === "ol")) {
+        const next = mapListAt(doc, pos.path, (list, index) => ({ ...list, items: list.items.map((item, i) => (i === index ? { ...item, bare: true } : item)) }));
+        return { doc: next, selection: caret(pos) };
+    }
     if (!held || held.index !== 0)
         return undefined;
     return leaveListItem(doc, pos);
@@ -351,7 +376,7 @@ export function splitListItem(doc, pos) {
     const item = held?.list.items[held.index];
     if (!loc || !item)
         return undefined;
-    if (content.length === 0 && item.sublists.length === 0)
+    if (content.length === 0 && item.children.length === 0)
         return leaveListItem(doc, pos);
     const before = sliceInline(content, 0, pos.offset);
     const after = sliceInline(content, pos.offset);
@@ -359,8 +384,8 @@ export function splitListItem(doc, pos) {
     const next = mapListAt(doc, pos.path, (list, index) => ({
         ...list,
         items: list.items.flatMap((candidate, i) => (i !== index ? [candidate] : [
-            { content: before, sublists: [], ...(item.checked !== undefined ? { checked: item.checked } : {}) },
-            { content: after, sublists: item.sublists, ...(item.checked !== undefined ? { checked: false } : {}) },
+            { content: before, children: [], ...(item.checked !== undefined ? { checked: item.checked } : {}), ...(item.id !== undefined ? { id: item.id } : {}) },
+            { content: after, children: item.children, ...(item.checked !== undefined ? { checked: false } : {}), ...(item.bare && after.length === 0 ? { bare: true } : {}) },
         ])),
     }));
     return { doc: next, selection: caret({ path: containerPaths(next)[ordinal + 1] ?? pos.path, offset: 0 }) };
@@ -377,11 +402,11 @@ export function insertIntoList(doc, pos, blocks, before, after) {
         if (!item)
             return list;
         const rows = others.length === 0
-            ? [{ content: normalizeInline([...before, ...first, ...after]), sublists: item.sublists }]
+            ? [{ ...item, content: normalizeInline([...before, ...first, ...after]) }]
             : [
-                { content: normalizeInline([...before, ...first]), sublists: [], ...(item.checked !== undefined ? { checked: item.checked } : {}) },
-                ...others.slice(0, -1).map((content) => ({ content, sublists: [], ...(item.checked !== undefined ? { checked: false } : {}) })),
-                { content: normalizeInline([...lastText, ...after]), sublists: item.sublists, ...(item.checked !== undefined ? { checked: false } : {}) },
+                { content: normalizeInline([...before, ...first]), children: [], ...(item.checked !== undefined ? { checked: item.checked } : {}), ...(item.id !== undefined ? { id: item.id } : {}) },
+                ...others.slice(0, -1).map((content) => ({ content, children: [], ...(item.checked !== undefined ? { checked: false } : {}) })),
+                { content: normalizeInline([...lastText, ...after]), children: item.children, ...(item.checked !== undefined ? { checked: false } : {}) },
             ];
         landing = rows.length - 1;
         return { ...list, items: [...list.items.slice(0, index), ...rows, ...list.items.slice(index + 1)] };

package/dist/markdown/detect.d.ts

@@ -0,0 +1 @@
+export declare function looksLikeMarkdown(input: string): boolean;

package/dist/markdown/detect.js

@@ -0,0 +1,81 @@
+const LIMIT = 200_000;
+const LINE_LIMIT = 2_000;
+const isList = (line) => /^ {0,6}(?:[-*+]|\d{1,9}[.)])[ \t]+\S/.test(line.slice(0, 64));
+const isRow = (line) => line.includes("|") && /^[\s|:-]+$/.test(line) && line.includes("-");
+function pair(text, mark) {
+    let from = 0;
+    for (let tries = 0; tries < 50; tries++) {
+        const a = text.indexOf(mark, from);
+        if (a === -1)
+            return false;
+        const inner = a + mark.length;
+        if (!/\s/.test(text.charAt(inner)) && inner < text.length) {
+            const b = text.indexOf(mark, inner + 1);
+            if (b !== -1 && !/\s/.test(text.charAt(b - 1)) && text.slice(inner, b).indexOf("\n\n") === -1)
+                return true;
+        }
+        from = a + mark.length;
+    }
+    return false;
+}
+function link(text) {
+    let from = 0;
+    for (let tries = 0; tries < 50; tries++) {
+        const mid = text.indexOf("](", from);
+        if (mid === -1)
+            return false;
+        const open = text.lastIndexOf("[", mid);
+        const close = text.indexOf(")", mid);
+        const label = open === -1 ? "" : text.slice(open + 1, mid);
+        if (open !== -1 && close !== -1 && label !== "" && !label.includes("\n") && close - mid < 2000)
+            return true;
+        from = mid + 2;
+    }
+    return false;
+}
+export function looksLikeMarkdown(input) {
+    const text = input.length > LIMIT ? input.slice(0, LIMIT) : input;
+    const lines = text.split(/\r\n?|\n/);
+    let headings = 0, listLines = 0, tasks = 0, quotes = 0, notes = 0;
+    let fence = false, table = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].slice(0, LINE_LIMIT);
+        if (/^ {0,3}(?:`{3,}|~{3,})/.test(line))
+            fence = true;
+        else if (/^ {0,3}#{1,6}[ \t]+\S/.test(line))
+            headings++;
+        else if (/^ {0,3}>/.test(line))
+            quotes++;
+        else if (/^ {0,3}\[\^[^\]\s]{1,64}\]:[ \t]*\S/.test(line))
+            notes++;
+        else if (isList(line)) {
+            listLines++;
+            if (/^\s*(?:[-*+]|\d+[.)])[ \t]+\[[ xX]\][ \t]/.test(line))
+                tasks++;
+        }
+        else if (line.includes("|") && i + 1 < lines.length && isRow(lines[i + 1].slice(0, LINE_LIMIT)) && line.replace(/[\s|]/g, "") !== "")
+            table = true;
+    }
+    let score = 0;
+    if (fence)
+        score += 3;
+    if (table)
+        score += 3;
+    if (headings > 0)
+        score += headings > 1 ? 2 : 1;
+    if (listLines >= 2)
+        score += 2;
+    if (tasks > 0)
+        score += 2;
+    if (quotes > 0)
+        score += 1;
+    if (notes > 0)
+        score += 2;
+    if (link(text))
+        score += 2;
+    if (pair(text, "**") || pair(text, "~~"))
+        score += 2;
+    if (pair(text, "`"))
+        score += 1;
+    return score >= 2;
+}

package/dist/markdown/export.d.ts

@@ -0,0 +1,10 @@
+import type { Doc } from "../model.ts";
+/** The document as Markdown (CommonMark with the GitHub table, task item and strikethrough additions). */
+export declare function exportMarkdown(doc: Doc, options?: MarkdownExportOptions): string;
+export interface MarkdownExportOptions {
+    /**
+     * Write underline, superscript and subscript as `<u>`, `<sup>` and `<sub>`, and a line break in a table cell or heading as `<br>`. The
+     * reader here understands those tags, so they come back; other Markdown readers show them as HTML. Default false: those details are dropped.
+     */
+    readonly inlineHtml?: boolean;
+}