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

package/dist/footnotes/reconcile.js

@@ -0,0 +1,155 @@
+const MAX_KEPT = 64;
+export function createReconciler(ops) {
+    const kept = new Map();
+    const keep = (id, item) => {
+        kept.delete(id);
+        kept.set(id, item);
+        if (kept.size > MAX_KEPT)
+            kept.delete(kept.keys().next().value);
+    };
+    const paragraph = { type: "br", paragraph: true };
+    const join = (a, b) => {
+        if (a.children.length > 0 && b.content.length > 0) {
+            const text = { type: "p", content: b.content };
+            return { item: { ...a, children: [...a.children, text, ...b.children] }, add: 0, childAdd: a.children.length };
+        }
+        const both = a.content.length > 0;
+        return {
+            item: { ...a, content: ops.normalizeInline([...a.content, ...(both ? [paragraph] : []), ...b.content]), children: [...a.children, ...b.children] },
+            add: both ? ops.inlineLength(a.content) + 1 : ops.inlineLength(a.content), childAdd: a.children.length,
+        };
+    };
+    return (doc, sel) => {
+        let current = doc;
+        const found = ops.noteIds(current);
+        const lists = current.blocks.flatMap((block, b) => (ops.isNotes(block) ? [b] : []));
+        if (found.length === 0 && lists.length === 0)
+            return { doc, selection: sel };
+        const copies = new Map();
+        if (new Set(found).size !== found.length) {
+            const used = new Set(found);
+            const seen = new Set();
+            const fresh = () => { for (let n = used.size + 1;; n++)
+                if (!used.has(`n${n}`)) {
+                    used.add(`n${n}`);
+                    return `n${n}`;
+                } };
+            for (const path of ops.containerPaths(current)) {
+                if (lists.includes(path[0]))
+                    continue;
+                const content = ops.getContent(current, path);
+                if (!content.some((n) => n.type === "note" && seen.has(n.id))) {
+                    for (const n of content)
+                        if (n.type === "note")
+                            seen.add(n.id);
+                    continue;
+                }
+                current = ops.setContent(current, path, content.map((n) => {
+                    if (n.type !== "note")
+                        return n;
+                    if (!seen.has(n.id)) {
+                        seen.add(n.id);
+                        return n;
+                    }
+                    const id = fresh();
+                    copies.set(id, n.id);
+                    return { type: "note", id };
+                }));
+            }
+        }
+        const ids = ops.noteIds(current);
+        const groups = new Map();
+        const moved = new Map();
+        let lead;
+        const leading = [];
+        let last;
+        let flat = 0;
+        const order = ids.filter((id, i) => ids.indexOf(id) === i);
+        for (const b of lists) {
+            current.blocks[b].items.forEach((item) => {
+                const id = item.id;
+                if (id !== undefined && !groups.has(id)) {
+                    const joined = lead ? join(lead, item) : { item, add: 0, childAdd: 0 };
+                    groups.set(id, joined.item === item ? item : { ...joined.item, id });
+                    last = id;
+                    for (const n of leading)
+                        moved.set(n, { index: order.indexOf(id), add: moved.get(n)?.add ?? 0, childAdd: 0 });
+                    moved.set(flat, { index: order.indexOf(id), add: joined.add, childAdd: joined.childAdd });
+                    lead = undefined;
+                    leading.length = 0;
+                }
+                else if (last !== undefined) {
+                    const { item: next, add, childAdd } = join(groups.get(last), item);
+                    groups.set(last, next);
+                    moved.set(flat, { index: order.indexOf(last), add, childAdd });
+                }
+                else {
+                    const joined = lead ? join(lead, item) : { item, add: 0, childAdd: 0 };
+                    lead = joined.item;
+                    moved.set(flat, { index: -1, add: joined.add, childAdd: joined.childAdd });
+                    leading.push(flat);
+                }
+                flat++;
+            });
+        }
+        if (lead && order[0] !== undefined) {
+            const target = order[0];
+            groups.set(target, groups.has(target) ? join(lead, groups.get(target)).item : { ...lead, id: target });
+            for (const n of leading)
+                moved.set(n, { index: 0, add: moved.get(n)?.add ?? 0, childAdd: 0 });
+        }
+        for (const [id, item] of groups)
+            if (!order.includes(id))
+                keep(id, item);
+        const wanted = order.map((id) => {
+            const have = groups.get(id);
+            if (have)
+                return have.id === id ? have : { ...have, id };
+            const source = copies.get(id);
+            const old = kept.get(id) ?? (source !== undefined ? groups.get(source) : undefined);
+            kept.delete(id);
+            return { ...(old ?? { content: [], children: [] }), id };
+        });
+        const first = lists[0];
+        const only = first !== undefined ? current.blocks[first] : undefined;
+        if (lists.length === 1 && only && only.items.length === wanted.length && only.items.every((item, i) => item === wanted[i]) && current === doc)
+            return { doc, selection: sel };
+        const block = wanted.length > 0 ? { ...(only ?? { type: "ol" }), type: "ol", notes: true, items: wanted } : undefined;
+        const blocks = [];
+        const newIndex = new Map();
+        current.blocks.forEach((b, i) => {
+            if (i === first) {
+                if (block) {
+                    newIndex.set(i, blocks.length);
+                    blocks.push(block);
+                }
+            }
+            else if (!lists.includes(i)) {
+                newIndex.set(i, blocks.length);
+                blocks.push(b);
+            }
+        });
+        const at = first === undefined && block ? blocks.length : (newIndex.get(first) ?? 0);
+        if (first === undefined && block)
+            blocks.push(block);
+        let offsetOf = 0;
+        const flatStart = new Map();
+        for (const b of lists) {
+            flatStart.set(b, offsetOf);
+            offsetOf += current.blocks[b].items.length;
+        }
+        const next = { blocks };
+        const map = (pos) => {
+            const [b, i, ...rest] = pos.path;
+            if (lists.includes(b)) {
+                const to = moved.get(flatStart.get(b) + i);
+                if (!to || !block)
+                    return ops.clampPos(next, { path: [Math.min(at, blocks.length - 1)], offset: 0 });
+                const [k, ...deeper] = rest;
+                return { path: k === undefined ? [at, to.index] : [at, to.index, k + to.childAdd, ...deeper], offset: pos.offset + (rest.length === 0 ? to.add : 0) };
+            }
+            return ops.clampPos(next, { path: [newIndex.get(b) ?? b, ...pos.path.slice(1)], offset: pos.offset });
+        };
+        return { doc: next, selection: { anchor: map(sel.anchor), focus: map(sel.focus) } };
+    };
+}

package/dist/images/images.js

@@ -1,4 +1,5 @@
 import { decodeBase64 } from "../base64.js";
+import { asChildren } from "../path.js";
 export function dataImageBytes(src) {
     const comma = src.indexOf(",");
     if (!/^data:/i.test(src) || comma === -1 || !/;base64$/i.test(src.slice(0, comma)))
@@ -26,8 +27,8 @@ export function mapImages(blocks, fn) {
     const list = (l) => {
         const items = l.items.flatMap((item) => {
             const { content, emptied } = inline(item.content);
-            const sublists = item.sublists.map(list).filter((x) => x !== undefined);
-            return emptied && sublists.length === 0 ? [] : [{ content, sublists }];
+            const children = asChildren(walk(item.children));
+            return emptied && children.length === 0 ? [] : [{ ...item, content, children }];
         });
         return items.length > 0 || l.items.length === 0 ? { ...l, items } : undefined;
     };
@@ -74,7 +75,7 @@ export function collectImages(blocks) {
     const inline = (content) => { for (const node of content)
         if (node.type === "image")
             found.push(node); };
-    const list = (l) => l.items.forEach((item) => { inline(item.content); item.sublists.forEach(list); });
+    const list = (l) => l.items.forEach((item) => { inline(item.content); walk(item.children); });
     const walk = (bs) => {
         for (const block of bs) {
             if (block.type === "p" || block.type === "h")

package/dist/images/index.d.ts

@@ -1,2 +1,6 @@
-export { images, type ImagesOptions } from "./plugin.ts";
+import { type ImagesOptions } from "./plugin.ts";
+import type { Plugin } from "../plugin.ts";
+export type { ImagesOptions };
+/** The images plugin, with the part that selects and resizes images in a browser. (`./plugin.ts` is the same without it.) */
+export declare const images: (options?: ImagesOptions) => Plugin;
 export { collectImages, dataImageBytes, isDataImage, mapImages, readDataImage, rewriteImages } from "./images.ts";

package/dist/images/index.js

@@ -1,2 +1,4 @@
-export { images } from "./plugin.js";
+import { images as engineOnly } from "./plugin.js";
+import { imagesView } from "./view.js";
+export const images = (options) => ({ ...engineOnly(options), view: imagesView });
 export { collectImages, dataImageBytes, isDataImage, mapImages, readDataImage, rewriteImages } from "./images.js";

package/dist/{dom/imageview.d.ts → images/view.d.ts}

@@ -1,15 +1,16 @@
-import type { Engine } from "../engine.ts";
+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 class ImageSelection {
-    private readonly root;
-    private readonly engine;
-    private readonly quiet;
+    private readonly host;
     private marked;
     private handle;
     private drag;
     private readonly stops;
-    constructor(root: HTMLElement, engine: Engine, quiet: () => void);
+    private readonly root;
+    private readonly engine;
+    private readonly quiet;
+    constructor(host: ViewHost);
     /** The drawn element of the selected image, or undefined. */
     private find;
     update(): void;
@@ -19,3 +20,5 @@ export declare class ImageSelection {
     private start;
     destroy(): void;
 }
+/** Images in the page: a click selects one, and its corner can be dragged to resize it. Comes with the images plugin. */
+export declare const imagesView: ViewExtension;

package/dist/{dom/imageview.js → images/view.js}

@@ -1,19 +1,20 @@
 import { imageSelection, selectedImage } from "../imageselect.js";
-import { domFromPos, posFromDom } from "./render.js";
 export const SELECTED_IMAGE = "data-rk-image-selected";
 const MIN = 16;
 export class ImageSelection {
-    root;
-    engine;
-    quiet;
+    host;
     marked;
     handle;
     drag;
     stops = [];
-    constructor(root, engine, quiet) {
-        this.root = root;
-        this.engine = engine;
-        this.quiet = quiet;
+    root;
+    engine;
+    quiet;
+    constructor(host) {
+        this.host = host;
+        this.root = host.element;
+        this.engine = host.engine;
+        this.quiet = () => host.quiet();
         const reposition = () => this.place();
         window.addEventListener("scroll", reposition, true);
         window.addEventListener("resize", reposition);
@@ -22,7 +23,7 @@ export class ImageSelection {
             const target = e.target;
             if (!(target instanceof HTMLImageElement) || !this.root.contains(target) || this.engine.readOnly)
                 return;
-            const at = posFromDom(this.root, target.parentNode, [...target.parentNode.childNodes].indexOf(target));
+            const at = this.host.posFromDom(target.parentNode, [...target.parentNode.childNodes].indexOf(target));
             if (at)
                 this.engine.setSelection(imageSelection(at.path, at.offset));
         };
@@ -34,7 +35,7 @@ export class ImageSelection {
         const picked = selectedImage(this.engine.document, this.engine.selection);
         if (!picked)
             return undefined;
-        const at = domFromPos(this.root, { path: picked.path, offset: picked.offset + 1 });
+        const at = this.host.domFromPos({ path: picked.path, offset: picked.offset + 1 });
         const el = !at ? undefined : at.node.nodeType === Node.TEXT_NODE ? at.node.previousSibling : at.node.childNodes[at.offset - 1];
         return el instanceof HTMLImageElement ? el : undefined;
     }
@@ -120,3 +121,8 @@ export class ImageSelection {
         this.marked?.removeAttribute(SELECTED_IMAGE);
     }
 }
+export const imagesView = (host) => {
+    const selection = new ImageSelection(host);
+    const stop = host.onChange(() => selection.update());
+    return () => { stop(); selection.destroy(); };
+};

package/dist/import.js

@@ -1,7 +1,9 @@
 import { decodeEntities } from "./html/entities.js";
 import { parseHtml } from "./html/parse.js";
 import { parseLine, SIDES, withSides } from "./cellborder.js";
-import { COLOR_VALUE, COLUMN_WIDTH, MAX_INDENT, ROW_HEIGHT, inlineText, normalizeInline, } from "./model.js";
+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 = 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",
@@ -275,6 +277,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 +299,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 +312,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 +476,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 +495,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 +508,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: [] }) - 1];
+            last.children.push(nested);
             continue;
         }
         if (child.tag !== "li")
@@ -497,19 +522,32 @@ 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;
+        }
         const level = levelOf(child.attrs["data-aria-level"] ?? child.attrs["aria-level"]);
         if (level !== undefined)
             item.level = level;
@@ -699,7 +737,6 @@ function padRows(rows) {
         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 +781,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: [] }) - 1];
+                    host.children.push(fresh);
                 }
                 else {
                     result.push(fresh);
@@ -757,15 +794,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 } : {}) }));
     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) => {

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { checkImageSrc, importBlocks, importHtml, importText, safeUrl, parseStyl
 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

@@ -4,6 +4,7 @@ export { checkImageSrc, importBlocks, importHtml, importText, safeUrl, parseStyl
 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 }] : [];
         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 }] : []), ...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: [] }), ...rest] };
         });
     }
     return { doc: next, selection: carry(doc, next, sel) };
@@ -279,16 +294,16 @@ 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 }] : [])],
+                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 };
         });
     }
@@ -351,7 +366,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 +374,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 } : {}) },
         ])),
     }));
     return { doc: next, selection: caret({ path: containerPaths(next)[ordinal + 1] ?? pos.path, offset: 0 }) };
@@ -377,11 +392,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;