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

package/dist/model.d.ts

@@ -31,7 +31,17 @@ export interface Image {
     readonly caption?: string;
 }
 export type ImageAlign = "left" | "right" | "center";
-export type Inline = TextRun | LineBreak | Image;
+/**
+ * A footnote reference: one character in the text, shown as the note's number. The note itself is an item of the document's notes
+ * list (`List.notes`) with the same `id`. Numbers are never stored: they come from the order of the references.
+ */
+export interface Note {
+    readonly type: "note";
+    readonly id: string;
+}
+export type Inline = TextRun | LineBreak | Image | Note;
+/** What an id of a note may be. Anything else is replaced when read, so an id is always safe in an attribute. */
+export declare const NOTE_ID: RegExp;
 export type Align = "left" | "center" | "right" | "justify";
 /** The most a block can be indented, in steps. */
 export declare const MAX_INDENT = 8;
@@ -56,17 +66,30 @@ export interface Heading {
 }
 export interface ListItem {
     readonly content: readonly Inline[];
-    readonly sublists: readonly List[];
+    /**
+     * What follows the item's own text, in order: nested lists, and also paragraphs, headings, code, quotes and rules. A paragraph
+     * that follows the text with nothing between is not a child but a paragraph break inside `content` (`br` with `paragraph`);
+     * a paragraph is a child only after another child (text, code, then more text).
+     */
+    readonly children: readonly ItemChild[];
     /** Present when the item is a task: whether it is done. Absent for an ordinary item. */
     readonly checked?: boolean;
+    /** In a notes list: the id of the reference this note belongs to. */
+    readonly id?: string;
 }
+/** What a list item may hold besides its own text. Tables and definition lists are not allowed in an item. */
+export type ItemChild = List | Paragraph | Heading | CodeBlock | Quote | Rule;
 export interface List {
     readonly type: "ul" | "ol";
     readonly start?: number;
     /** A CSS list-style-type keyword such as `circle` or `lower-alpha`. Absent means the default for the depth. */
     readonly style?: string;
+    /** The footnotes of the document: a numbered list whose items are the notes, kept in the order of their references. */
+    readonly notes?: true;
     readonly items: readonly ListItem[];
 }
+/** The marker a list has when it names none: numbers for an ordered list, and a bullet by depth for the rest. */
+export declare const DEFAULT_MARKER: (type: "ul" | "ol", depth: number) => string;
 export interface DefinitionEntry {
     /** A term (`dt`) or the detail that describes it (`dd`). */
     readonly kind: "term" | "detail";

package/dist/model.js

@@ -1,4 +1,6 @@
+export const NOTE_ID = /^[A-Za-z0-9_-]{1,40}$/;
 export const MAX_INDENT = 8;
+export const DEFAULT_MARKER = (type, depth) => (type === "ol" ? "decimal" : ["disc", "circle", "square"][Math.min(depth, 2)]);
 export const ROW_HEIGHT = /^\d{1,4}(\.\d{1,2})?px$/;
 export const COLOR_VALUE = /^(#[0-9a-f]{3,8}|[a-z]{3,20}|(?:rgb|hsl)a?\([\d\s.,%/-]+\))$/i;
 export const COLUMN_WIDTH = /^\d{1,5}(\.\d{1,2})?(px|%)$/;

package/dist/notes.d.ts

@@ -0,0 +1,6 @@
+import type { Block, Doc, List } from "./model.ts";
+export declare const isNotes: (block: Block | undefined) => block is List & {
+    notes: true;
+};
+/** The ids of every reference in the document, in reading order. */
+export declare const noteIds: (doc: Doc) => string[];

package/dist/notes.js

@@ -0,0 +1,49 @@
+export const isNotes = (block) => block?.type === "ol" && block.notes === true;
+function collect(block, out) {
+    const inline = (content) => { for (const n of content)
+        if (n.type === "note")
+            out.push(n.id); };
+    switch (block.type) {
+        case "p":
+        case "h":
+            inline(block.content);
+            break;
+        case "ul":
+        case "ol":
+            for (const item of block.items) {
+                inline(item.content);
+                for (const child of item.children)
+                    collect(child, out);
+            }
+            break;
+        case "dl":
+            for (const entry of block.entries)
+                inline(entry.content);
+            break;
+        case "table":
+            for (const row of block.rows)
+                for (const cell of row)
+                    for (const inner of cell.blocks)
+                        collect(inner, out);
+            break;
+        case "quote":
+            for (const inner of block.blocks)
+                collect(inner, out);
+            break;
+        default: break;
+    }
+}
+const found = new WeakMap();
+const NONE = [];
+function idsOf(block) {
+    if (isNotes(block))
+        return NONE;
+    let ids = found.get(block);
+    if (!ids) {
+        const out = [];
+        collect(block, out);
+        found.set(block, (ids = out.length === 0 ? NONE : out));
+    }
+    return ids;
+}
+export const noteIds = (doc) => doc.blocks.flatMap(idsOf);

package/dist/ops.d.ts

@@ -3,6 +3,7 @@ import { deleteBackward, deleteForward, deleteSelection, extractSelection, inser
 import { exportBlock, exportHtml, exportInline } from "./export.ts";
 import { importBlocks, importHtml, importText } from "./import.ts";
 import { setLink } from "./links.ts";
+import { isNotes, noteIds } from "./notes.ts";
 import { decodeBase64, encodeBase64 } from "./base64.ts";
 import { escapeAttribute, escapeText } from "./html/entities.ts";
 import { checkImageSrc, parseStyle } from "./import.ts";
@@ -10,8 +11,11 @@ import { imageSelection, selectedImage } from "./imageselect.ts";
 import { sameLine, sidesOf, withSides } from "./cellborder.ts";
 import { extent, fromGrid, inRow, locateCell, meets, selectedCells, selectedRect, toGrid } from "./tablegrid.ts";
 import { inlineLength, inlineText, normalizeInline } from "./model.ts";
-import { caret, clampPos, containerPaths, fixup, getBlock, getContent, isCollapsed, kindAt, mapBlockList, pathKey, selectedContainers, setContent } from "./path.ts";
+import { asChildren, caret, clampPos, containerPaths, fixup, getBlock, getContent, isCollapsed, kindAt, mapBlockList, pathKey, selectedContainers, setContent } from "./path.ts";
 export declare const ops: {
+    readonly isNotes: typeof isNotes;
+    readonly noteIds: typeof noteIds;
+    readonly asChildren: typeof asChildren;
     readonly caret: typeof caret;
     readonly clampPos: typeof clampPos;
     readonly containerPaths: typeof containerPaths;
@@ -28,6 +32,7 @@ export declare const ops: {
     readonly inlineText: typeof inlineText;
     readonly normalizeInline: typeof normalizeInline;
     readonly sliceInline: typeof sliceInline;
+    readonly NOTE_ID: RegExp;
     readonly COLUMN_WIDTH: RegExp;
     readonly COLOR_VALUE: RegExp;
     readonly ROW_HEIGHT: RegExp;

package/dist/ops.js

@@ -3,17 +3,18 @@ import { deleteBackward, deleteForward, deleteSelection, extractSelection, inser
 import { exportBlock, exportHtml, exportInline } from "./export.js";
 import { importBlocks, importHtml, importText } from "./import.js";
 import { setLink } from "./links.js";
+import { isNotes, noteIds } from "./notes.js";
 import { decodeBase64, encodeBase64 } from "./base64.js";
 import { escapeAttribute, escapeText } from "./html/entities.js";
 import { checkImageSrc, parseStyle } from "./import.js";
 import { imageSelection, selectedImage } from "./imageselect.js";
 import { sameLine, SIDES, sidesOf, withSides } from "./cellborder.js";
 import { extent, fromGrid, inRow, locateCell, meets, selectedCells, selectedRect, toGrid } from "./tablegrid.js";
-import { COLOR_VALUE, COLUMN_WIDTH, ROW_HEIGHT, inlineLength, inlineText, normalizeInline } from "./model.js";
-import { caret, clampPos, containerPaths, fixup, getBlock, getContent, isCollapsed, kindAt, mapBlockList, pathKey, selectedContainers, setContent, } from "./path.js";
+import { NOTE_ID, COLOR_VALUE, COLUMN_WIDTH, ROW_HEIGHT, inlineLength, inlineText, normalizeInline } from "./model.js";
+import { asChildren, caret, clampPos, containerPaths, fixup, getBlock, getContent, isCollapsed, kindAt, mapBlockList, pathKey, selectedContainers, setContent, } from "./path.js";
 export const ops = {
-    caret, clampPos, containerPaths, selectedContainers, getContent, setContent, getBlock, kindAt, mapBlockList, fixup, pathKey, isCollapsed,
-    inlineLength, inlineText, normalizeInline, sliceInline, COLUMN_WIDTH, COLOR_VALUE, ROW_HEIGHT, imageSelection, selectedImage, sameLine, SIDES, sidesOf, withSides,
+    isNotes, noteIds, asChildren, caret, clampPos, containerPaths, selectedContainers, getContent, setContent, getBlock, kindAt, mapBlockList, fixup, pathKey, isCollapsed,
+    inlineLength, inlineText, normalizeInline, sliceInline, NOTE_ID, COLUMN_WIDTH, COLOR_VALUE, ROW_HEIGHT, imageSelection, selectedImage, sameLine, SIDES, sidesOf, withSides,
     toGrid, fromGrid, inRow, extent, meets, selectedRect, selectedCells, locateCell,
     parseStyle, checkImageSrc, escapeText, escapeAttribute, encodeBase64, decodeBase64,
     insertText, insertBlocks, insertLineBreak, splitBlock, deleteSelection, deleteBackward, deleteForward, moveSelection,

package/dist/path.d.ts

@@ -1,4 +1,4 @@
-import { type Block, type Doc, type Inline, type List } from "./model.ts";
+import { type Block, type Doc, type Inline, type ItemChild, type List } from "./model.ts";
 export type Path = readonly number[];
 export interface Pos {
     readonly path: Path;
@@ -35,6 +35,8 @@ export declare function kindAt(doc: Doc, path: Path): "p" | "h" | "pre" | "li" |
 export declare const setContent: (doc: Doc, path: Path, content: readonly Inline[]) => Doc;
 /** Replaces the block that holds a container (a paragraph, heading or code block) in its parent list of blocks. */
 export declare function mapBlockList(doc: Doc, path: Path, fn: (blocks: readonly Block[], index: number) => readonly Block[]): Doc;
+/** Blocks as list item children: a table or definition list cannot sit in an item, so its text stays as paragraphs. */
+export declare function asChildren(blocks: readonly Block[]): ItemChild[];
 /** The block at a path that ends at a block: `[b]`, `[b, n]` inside a quote, `[b, r, c, n]` inside a table cell. */
 export declare function getBlock(doc: Doc, path: Path): Block | undefined;
 /** True when the container is a direct child of a list of blocks (so blocks can be inserted beside it). */

package/dist/path.js

@@ -14,7 +14,7 @@ export function comparePath(a, b) {
 function listPaths(list, prefix, out) {
     list.items.forEach((item, i) => {
         out.push([...prefix, i]);
-        item.sublists.forEach((sub, k) => listPaths(sub, [...prefix, i, k], out));
+        item.children.forEach((child, k) => blockPaths(child, [...prefix, i, k], out));
     });
 }
 function blockPaths(block, prefix, out) {
@@ -83,8 +83,8 @@ function slotInList(list, rest) {
         return undefined;
     if (k === undefined)
         return { content: item.content, item };
-    const sub = item.sublists[k];
-    return sub ? slotInList(sub, more) : undefined;
+    const child = item.children[k];
+    return child ? slotInBlock(child, more) : undefined;
 }
 function slotInBlocks(blocks, rest) {
     const [n, ...more] = rest;
@@ -114,7 +114,7 @@ function updateList(list, rest, content) {
             return item;
         if (k === undefined)
             return { ...item, content };
-        return { ...item, sublists: item.sublists.map((sub, s) => (s === k ? updateList(sub, more, content) : sub)) };
+        return { ...item, children: item.children.map((child, s) => (s === k ? updateBlock(child, more, content) : child)) };
     });
     return { ...list, items };
 }
@@ -143,6 +143,28 @@ function updateBlocks(blocks, rest, content) {
 }
 export const setContent = (doc, path, content) => ({ blocks: updateBlocks(doc.blocks, path, content) });
 export function mapBlockList(doc, path, fn) {
+    const applyList = (list, rest) => {
+        const [i, k, ...more] = rest;
+        if (i === undefined || k === undefined)
+            return list;
+        return { ...list, items: list.items.map((item, idx) => (idx !== i ? item : { ...item, children: applyChildren(item.children, [k, ...more]) })) };
+    };
+    const applyChildren = (children, rest) => {
+        const [k, ...more] = rest;
+        if (k === undefined)
+            return [...children];
+        if (more.length === 0)
+            return asChildren(fn(children, k));
+        return children.map((child, idx) => {
+            if (idx !== k)
+                return child;
+            if (child.type === "ul" || child.type === "ol")
+                return applyList(child, more);
+            if (child.type === "quote")
+                return { ...child, blocks: apply(child.blocks, more) };
+            return child;
+        });
+    };
     const apply = (blocks, rest) => {
         const [n, ...more] = rest;
         if (n === undefined)
@@ -154,6 +176,8 @@ export function mapBlockList(doc, path, fn) {
                 return block;
             if (block.type === "quote")
                 return { ...block, blocks: apply(block.blocks, more) };
+            if (block.type === "ul" || block.type === "ol")
+                return applyList(block, more);
             if (block.type === "table") {
                 const [r, c, ...inner] = more;
                 return { ...block, rows: block.rows.map((row, ri) => (ri !== r ? row : row.map((cell, ci) => (ci !== c ? cell : { ...cell, blocks: apply(cell.blocks, inner) })))) };
@@ -163,6 +187,15 @@ export function mapBlockList(doc, path, fn) {
     };
     return { blocks: apply(doc.blocks, path) };
 }
+export function asChildren(blocks) {
+    return blocks.flatMap((block) => {
+        switch (block.type) {
+            case "table": return block.rows.flatMap((row) => row.flatMap((cell) => asChildren(cell.blocks)));
+            case "dl": return block.entries.map((entry) => ({ type: "p", content: entry.content }));
+            default: return [block];
+        }
+    });
+}
 export function getBlock(doc, path) {
     const find = (blocks, rest) => {
         const [n, ...more] = rest;
@@ -171,6 +204,8 @@ export function getBlock(doc, path) {
             return block;
         if (block.type === "quote")
             return find(block.blocks, more);
+        if (block.type === "ul" || block.type === "ol")
+            return findInList(block, more);
         if (block.type === "table") {
             const [r, c, ...inner] = more;
             const cell = r === undefined || c === undefined ? undefined : block.rows[r]?.[c];
@@ -178,6 +213,17 @@ export function getBlock(doc, path) {
         }
         return undefined;
     };
+    const findInList = (list, rest) => {
+        const [i, k, ...inner] = rest;
+        const child = i === undefined || k === undefined ? undefined : list.items[i]?.children[k];
+        if (!child)
+            return undefined;
+        if (inner.length === 0)
+            return child;
+        if (child.type === "ul" || child.type === "ol")
+            return findInList(child, inner);
+        return child.type === "quote" ? find(child.blocks, inner) : undefined;
+    };
     return find(doc.blocks, path);
 }
 export function inBlockList(doc, path) {
@@ -193,7 +239,18 @@ export function mapListOf(doc, path, fn) {
             return fn(list, i);
         return {
             ...list,
-            items: list.items.map((item, idx) => idx !== i ? item : { ...item, sublists: item.sublists.flatMap((sub, s) => (s === k ? [apply(sub, more)].filter((x) => x !== undefined) : [sub])) }),
+            items: list.items.map((item, idx) => idx !== i ? item : {
+                ...item,
+                children: item.children.flatMap((sub, s) => {
+                    if (s !== k)
+                        return [sub];
+                    if (sub.type === "ul" || sub.type === "ol") {
+                        const next = apply(sub, more);
+                        return next ? [next] : [];
+                    }
+                    return sub.type === "quote" ? [{ ...sub, blocks: walk(sub.blocks, more) }] : [sub];
+                }),
+            }),
         };
     };
     const walk = (blocks, rest) => {
@@ -226,10 +283,27 @@ export function fixup(doc) {
             if (block.type === "table") {
                 return [{ ...block, rows: block.rows.map((row) => row.map((cell) => ({ ...cell, blocks: fixBlocks(cell.blocks, true) }))) }];
             }
+            if (block.type === "ul" || block.type === "ol")
+                return [fixList(block)];
             return [block];
         });
         return out.length === 0 && needOne ? [{ type: "p", content: [] }] : out;
     };
+    const fixList = (list) => ({
+        ...list,
+        items: list.items.map((item) => ({
+            ...item,
+            children: item.children.flatMap((child) => {
+                if (child.type === "ul" || child.type === "ol")
+                    return [fixList(child)];
+                if (child.type === "quote") {
+                    const inner = fixBlocks(child.blocks, false);
+                    return inner.length > 0 ? [{ ...child, blocks: inner }] : [];
+                }
+                return [child];
+            }),
+        })),
+    });
     return { blocks: fixBlocks(doc.blocks, true) };
 }
 export function clampPos(doc, pos) {
@@ -258,6 +332,8 @@ export function cellChain(doc, path) {
             return;
         if (block.type === "quote")
             walk(block.blocks, more, [...prefix, n]);
+        else if (block.type === "ul" || block.type === "ol")
+            walkList(block, more, [...prefix, n]);
         else if (block.type === "table") {
             const [r, c, ...inner] = more;
             if (r === undefined || c === undefined)
@@ -268,6 +344,16 @@ export function cellChain(doc, path) {
                 walk(cell.blocks, inner, [...prefix, n, r, c]);
         }
     };
+    const walkList = (list, rest, prefix) => {
+        const [i, k, ...inner] = rest;
+        const child = i === undefined || k === undefined ? undefined : list.items[i]?.children[k];
+        if (i === undefined || k === undefined || !child)
+            return;
+        if (child.type === "ul" || child.type === "ol")
+            walkList(child, inner, [...prefix, i, k]);
+        else if (child.type === "quote")
+            walk(child.blocks, inner, [...prefix, i, k]);
+    };
     walk(doc.blocks, path, []);
     return chain;
 }

package/dist/plugin.d.ts

@@ -3,13 +3,58 @@ import type { CommandDef, Unsubscribe } from "./commands.ts";
 import type { Engine } from "./engine.ts";
 import type { ImportOptions } from "./import.ts";
 import type { KeyBinding } from "./keymap.ts";
-import type { Block } from "./model.ts";
+import type { Block, Doc } from "./model.ts";
+import type { EditResult, Pos, Selection } from "./path.ts";
 import type { UiItem, UiSlot } from "./ui.ts";
 import type { Ops } from "./ops.ts";
 import type { PasteHandler } from "./paste.ts";
 export declare const PLUGIN_API_VERSION = 1;
 /** Looks at blocks about to be pasted and returns the blocks to insert. May take time (an upload); then the paste waits. */
 export type PasteTransform = (blocks: readonly Block[]) => readonly Block[] | Promise<readonly Block[]>;
+/**
+ * Gives the formats a copy, cut or drag writes besides the editor's own HTML and plain text: `{ "text/markdown": "..." }`.
+ * Return a format the editor already writes (`text/plain`, `text/html`) to replace it. Return undefined to add nothing.
+ * Called once per copy with the selected blocks; it must be quick and must not change the document.
+ */
+export type CopyFormatter = (blocks: readonly Block[]) => Readonly<Record<string, string>> | undefined;
+/**
+ * Puts right what an edit left, such as a footnote whose reference was deleted. Runs after every edit that changes the document, on
+ * the result, and returns the document and selection to use; the repair is part of the same undo step. It must be quick, and
+ * must return the same document when there is nothing to put right.
+ */
+export type Normalizer = (doc: Doc, selection: Selection) => EditResult;
+/** What changed in the editor, as the page-facing part of a plugin hears of it. */
+export interface ViewChange {
+    readonly docChanged: boolean;
+    readonly selectionChanged: boolean;
+    /** The editor gained or lost the focus. */
+    readonly focusMoved: boolean;
+}
+/**
+ * What the browser view gives the page-facing part of a plugin. Types that name the page (`HTMLElement`, `Node`) are written
+ * as `object` here so this file stays free of the DOM; the plugin's view file knows what they are.
+ */
+export interface ViewHost {
+    /** The element the editor is drawn in (an `HTMLElement`). */
+    readonly element: object;
+    readonly engine: Engine;
+    readonly ops: Ops;
+    /** Adds an event listener that is taken away again when the editor or the plugin is. */
+    listen(target: object, type: string, handler: (event: never) => void): void;
+    /** Called after the page was changed by the plugin itself, so the editor does not take it for a change from outside. */
+    quiet(): void;
+    /** Called after the editor has drawn each change. */
+    onChange(listener: (change: ViewChange) => void): Unsubscribe;
+    /** The position in the document for a place in the page (`Node`, offset), or null. */
+    posFromDom(node: object, offset: number): Pos | null;
+    /** The place in the page (`Node`, offset) for a position in the document, or null. */
+    domFromPos(pos: Pos): {
+        readonly node: object;
+        readonly offset: number;
+    } | null;
+}
+/** The page-facing part of a plugin: set up once the editor has a page, returns what takes it away again. */
+export type ViewExtension = (host: ViewHost) => void | Unsubscribe;
 /** What a plugin needs of a file that was pasted or dropped. A browser `File` fits. */
 export interface BlobLike {
     readonly type: string;
@@ -32,6 +77,10 @@ export interface PluginHost {
     command<A, V>(def: CommandDef<A, V>): void;
     keybinding(binding: KeyBinding): void;
     pasteHandler(handler: PasteHandler): void;
+    /** Adds a repair that runs after every edit that changes the document. */
+    normalize(normalizer: Normalizer): void;
+    /** Adds formats to what copy, cut and drag write to the clipboard. Later plugins win when two give the same type. */
+    copyFormat(formatter: CopyFormatter): void;
     /** Takes over Enter, Backspace at the start, and paste inside a kind of container the plugin owns. One plugin per kind. */
     behavior(kind: ContainerKind, behavior: ContainerBehavior): void;
     /** Watches typed text before it is inserted, to turn a shortcut into something else. */
@@ -51,6 +100,8 @@ export interface Plugin {
     /** The plugin API versions it supports: `1`, `1.x`, or a range such as `>=1 <3`. A mismatch fails when it is added. */
     readonly api: string;
     setup(host: PluginHost): void | Unsubscribe;
+    /** Only in a browser: the part that draws and handles things on the page (table handles, say). The engine never calls it. */
+    readonly view?: ViewExtension;
 }
 /** Whether a version satisfies a range written as `N`, `N.x`, `>=N`, `<N` or a pair like `>=1 <3`. */
 export declare function satisfiesApi(range: string, version: number): boolean;

package/dist/standard/index.d.ts

@@ -1,9 +1,10 @@
 import { type AutoformatOptions } from "../autoformat/plugin.ts";
 import { Editor, type EditorOptions } from "../dom/view.ts";
-import { type ImagesOptions } from "../images/plugin.ts";
+import { type FootnotesOptions } from "../footnotes/plugin.ts";
+import { type ImagesOptions } from "../images/index.ts";
 import { type ListsOptions } from "../lists/plugin.ts";
 import type { Plugin } from "../plugin.ts";
-import { type TablesOptions } from "../tables/plugin.ts";
+import { type TablesOptions } from "../tables/index.ts";
 /** Which standard plugins to use, and how. */
 export interface StandardPluginOptions extends ImagesOptions {
     /** Options for lists, or `false` to leave lists out. */
@@ -14,6 +15,8 @@ export interface StandardPluginOptions extends ImagesOptions {
     readonly find?: false;
     /** Options for tables, or `false` to leave tables out. */
     readonly tables?: TablesOptions | false;
+    /** Options for footnotes, or `false` to leave them out. */
+    readonly footnotes?: FootnotesOptions | false;
     /** More plugins, added after the standard ones. */
     readonly plugins?: readonly Plugin[];
 }

package/dist/standard/index.js

@@ -1,10 +1,11 @@
 import { autoformat } from "../autoformat/plugin.js";
 import { Editor } from "../dom/view.js";
 import { find } from "../find/plugin.js";
-import { images } from "../images/plugin.js";
+import { footnotes } from "../footnotes/plugin.js";
+import { images } from "../images/index.js";
 import { lists } from "../lists/plugin.js";
 import { svg } from "../svg/plugin.js";
-import { tables } from "../tables/plugin.js";
+import { tables } from "../tables/index.js";
 import { word } from "../word/plugin.js";
 export function standardPlugins(options = {}) {
     const { uploadImage, maxInlineImageBytes, maxImageFileBytes, onImageRejected } = options;
@@ -13,6 +14,7 @@ export function standardPlugins(options = {}) {
         ...(options.tables === false ? [] : [tables(options.tables)]),
         ...(options.find === false ? [] : [find()]),
         ...(options.autoformat === false ? [] : [autoformat(options.autoformat)]),
+        ...(options.footnotes === false ? [] : [footnotes(options.footnotes)]),
         word(),
         svg(),
         images({
@@ -25,8 +27,8 @@ export function standardPlugins(options = {}) {
     ];
 }
 export function createEditor(options) {
-    const { lists: _lists, tables: _tables, find: _find, autoformat: _autoformat, plugins: _plugins, uploadImage: _u, maxInlineImageBytes: _m, maxImageFileBytes: _f, onImageRejected: _r, ...editorOptions } = options;
-    void [_lists, _tables, _find, _autoformat, _plugins, _u, _m, _f, _r];
+    const { lists: _lists, tables: _tables, find: _find, autoformat: _autoformat, footnotes: _footnotes, plugins: _plugins, uploadImage: _u, maxInlineImageBytes: _m, maxImageFileBytes: _f, onImageRejected: _r, ...editorOptions } = options;
+    void [_lists, _tables, _find, _autoformat, _footnotes, _plugins, _u, _m, _f, _r];
     return new Editor({ ...editorOptions, plugins: standardPlugins(options) });
 }
 export { Editor };

package/dist/{dom/tableview.d.ts → tables/cells.d.ts}

@@ -1,4 +1,4 @@
-import type { Engine } from "../engine.ts";
+import type { ViewHost } from "../plugin.ts";
 /** The attribute on a cell that a selection covers, for styling. */
 export declare const SELECTED_CELL = "data-rk-cell-selected";
 /**
@@ -6,11 +6,12 @@ export declare const SELECTED_CELL = "data-rk-cell-selected";
  * attributes on the drawn cells, not part of the model, and they are put on again after every change.
  */
 export declare class CellMarks {
+    private readonly host;
+    private marked;
     private readonly root;
     private readonly engine;
-    private readonly quiet;
-    private marked;
-    constructor(root: HTMLElement, engine: Engine, quiet: () => void);
+    constructor(host: ViewHost);
+    private quiet;
     update(): void;
 }
 /**
@@ -19,4 +20,4 @@ export declare class CellMarks {
  * The bottom edge of a row works the same way through `table.rowHeight`.
  * Returns what takes it away again.
  */
-export declare function installColumnResize(root: HTMLElement, engine: Engine, listen: (target: EventTarget, type: string, handler: (event: Event) => void) => void, quiet: () => void): void;
+export declare function installColumnResize(host: ViewHost): void;

package/dist/{dom/tableview.js → tables/cells.js}

@@ -1,20 +1,20 @@
 import { pathKey } from "../path.js";
 import { inRow, locateCell, selectedCells } from "../tablegrid.js";
-import { posFromDom } from "./render.js";
 export const SELECTED_CELL = "data-rk-cell-selected";
 const GRAB = 5;
 const MIN_WIDTH = 24;
 const MIN_HEIGHT = 16;
 export class CellMarks {
+    host;
+    marked = [];
     root;
     engine;
-    quiet;
-    marked = [];
-    constructor(root, engine, quiet) {
-        this.root = root;
-        this.engine = engine;
-        this.quiet = quiet;
+    constructor(host) {
+        this.host = host;
+        this.root = host.element;
+        this.engine = host.engine;
     }
+    quiet() { this.host.quiet(); }
     update() {
         const sel = this.engine.selection;
         const found = pathKey(sel.anchor.path) === pathKey(sel.focus.path) ? undefined : selectedCells(this.engine.document, sel);
@@ -56,11 +56,15 @@ function rowEdgeAt(root, event) {
     const box = row.getBoundingClientRect();
     return event.clientY >= box.bottom - GRAB && event.clientY <= box.bottom + GRAB ? cell : null;
 }
-export function installColumnResize(root, engine, listen, quiet) {
+export function installColumnResize(host) {
+    const root = host.element;
+    const engine = host.engine;
+    const quiet = () => host.quiet();
+    const listen = (target, type, handler) => host.listen(target, type, handler);
     const available = () => !engine.readOnly && engine.commands.list().some((c) => c.name === "table.columnWidth");
     const cellPath = (cell) => {
         const inside = cell.querySelector("[data-rte]");
-        return inside ? posFromDom(root, inside, 0)?.path : undefined;
+        return inside ? host.posFromDom(inside, 0)?.path : undefined;
     };
     const rowAvailable = () => !engine.readOnly && engine.commands.list().some((c) => c.name === "table.rowHeight");
     let rowDrag;

package/dist/{dom/tablegrips.d.ts → tables/grips.d.ts}

@@ -1,7 +1,6 @@
-import type { Engine } from "../engine.ts";
+import type { ViewHost } from "../plugin.ts";
 export declare class TableGrips {
-    private readonly root;
-    private readonly engine;
+    private readonly host;
     private readonly grips;
     private guide;
     private readonly stops;
@@ -9,7 +8,9 @@ export declare class TableGrips {
     private table;
     private path;
     private touch;
-    constructor(root: HTMLElement, engine: Engine);
+    private readonly root;
+    private readonly engine;
+    constructor(host: ViewHost);
     private available;
     /** The drawn cell the caret is in, and its table, when the table is at the top level. Found from the page, so it costs nothing in a big table. */
     private find;

package/dist/{dom/tablegrips.js → tables/grips.js}

@@ -1,11 +1,9 @@
 import { getBlock } from "../path.js";
 import { inRow, locateCell, toGrid } from "../tablegrid.js";
-import { domFromPos } from "./render.js";
 const SIZE = 22;
 const COLOR = "#17408b";
 export class TableGrips {
-    root;
-    engine;
+    host;
     grips = new Map();
     guide;
     stops = [];
@@ -13,9 +11,12 @@ export class TableGrips {
     table;
     path = [];
     touch = false;
-    constructor(root, engine) {
-        this.root = root;
-        this.engine = engine;
+    root;
+    engine;
+    constructor(host) {
+        this.host = host;
+        this.root = host.element;
+        this.engine = host.engine;
         const reposition = () => this.place();
         window.addEventListener("scroll", reposition, true);
         window.addEventListener("resize", reposition);
@@ -40,7 +41,7 @@ export class TableGrips {
         const top = this.root.children[path[0]];
         if (!(top instanceof HTMLElement) || top.tagName !== "TABLE")
             return undefined;
-        const at = domFromPos(this.root, this.engine.selection.focus);
+        const at = this.host.domFromPos(this.engine.selection.focus);
         const from = at ? (at.node instanceof Element ? at.node : at.node.parentElement) : null;
         const cell = from?.closest("td, th");
         return cell instanceof HTMLElement && cell.closest("table") === top ? { cell, table: top, path } : undefined;

package/dist/tables/index.d.ts

@@ -1,2 +1,6 @@
-export { tables, type TablesOptions } from "./plugin.ts";
+import { type TablesOptions } from "./plugin.ts";
+import type { Plugin } from "../plugin.ts";
+export type { TablesOptions };
+/** The tables plugin, with the part that draws table handles in a browser. (`./plugin.ts` is the same without it.) */
+export declare const tables: (options?: TablesOptions) => Plugin;
 export { BORDER_PRESETS, borderPreset, cellBackground, cellBorderPreset, rowHeight, setCellBackground, setCellBorder, setRowHeight, columnWidth, setColumnWidth, canMerge, canSplit, deleteColumn, deleteRow, deleteTable, hasHeaderRow, inTable, insertColumn, insertRow, insertTable, makeTable, mergeCells, moveToCell, splitCell, toggleHeaderRow, type InsertTableOptions } from "./tables.ts";

package/dist/tables/index.js

@@ -1,2 +1,4 @@
-export { tables } from "./plugin.js";
+import { tables as engineOnly } from "./plugin.js";
+import { tablesView } from "./view.js";
+export const tables = (options) => ({ ...engineOnly(options), view: tablesView });
 export { BORDER_PRESETS, borderPreset, cellBackground, cellBorderPreset, rowHeight, setCellBackground, setCellBorder, setRowHeight, columnWidth, setColumnWidth, canMerge, canSplit, deleteColumn, deleteRow, deleteTable, hasHeaderRow, inTable, insertColumn, insertRow, insertTable, makeTable, mergeCells, moveToCell, splitCell, toggleHeaderRow } from "./tables.js";