@quillmark/svelte 0.1.1 → 0.3.0

package/dist/core/codec/clipboard.d.ts

@@ -0,0 +1,59 @@
+import { DOMParser as PMDOMParser, Slice } from 'prosemirror-model';
+import type { Node as PMNode, Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import type { TableCell, TableProps } from '@quillmark/wasm';
+import { type TableAlign } from './table.js';
+/** What a clipboard event hands over, which is all either arm needs of it: jsdom has no
+ *  `DataTransfer`, and the suite drives these paths with the two methods themselves. */
+interface Clipboard {
+    getData: (type: string) => string;
+    setData: (type: string, data: string) => void;
+}
+/**
+ * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
+ * rectangle, so a table with one arrives with the rows below it short and
+ * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
+ * covers, so the columns after it keep their index.
+ *
+ * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
+ * reader is about to flatten, not to a rank of this one.
+ */
+export declare function tableFromDOM(dom: Element): TableProps;
+/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
+ *  one: a clipboard holding a table among other blocks is a document paste, and only a
+ *  surface that takes nothing but a table (a cell) reads it this way. */
+export declare function tableFromClipboard(data: Clipboard | null | undefined): TableProps | undefined;
+/**
+ * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
+ * a `<th>` row whatever row of the source it came from, that being the row index 0 a
+ * paste lands it at.
+ */
+export declare function tableToDOM(block: TableCell[][], aligns: TableAlign[], owner: Document): Element;
+/**
+ * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
+ * table and what markdown carries. The delimiter follows the first row for the reason
+ * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
+ */
+export declare function tableToPipe(block: TableCell[][], aligns: TableAlign[]): string;
+/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
+ *  over a selection its own surface holds, so the rectangle arrives already cut out and
+ *  claiming the event is the caller's. */
+export declare function writeRectangle(data: Clipboard, block: TableCell[][], aligns: TableAlign[], owner: Document): void;
+/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
+ *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
+ *  through to the enclosing block. */
+export declare function tableClipboardParser(schema: Schema): PMDOMParser;
+/** Mint an id for every island a paste is carrying. An id is part of the document's
+ *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
+ *  pasted island with none reaches the store as an insert nothing can name afterwards.
+ *  One minter for the whole slice, or a paste placing two tables hands them one id. */
+export declare function stampIslandIds(slice: Slice, doc: PMNode): Slice;
+/**
+ * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
+ * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
+ * because what a `<table>` in the DOM means is a question only the clipboard asks — the
+ * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
+ * where an island is already a node and a `<table>` is the chrome drawing one.
+ */
+export declare function tableClipboardPlugin(schema: Schema): Plugin;
+export {};

package/dist/core/codec/clipboard.js

@@ -0,0 +1,202 @@
+// The table island's clipboard door, both directions: what a copy writes, a paste
+// reads. The design and the two wire formats are CODEC §"The table island" and
+// §"Markdown at the edges"; what is here is the grammar.
+//
+// What crosses is A rectangle, never a cell. A `<table>` read in is one; the held cell
+// selection written out is one; a rectangle overlaid onto a table at a cell is one. The
+// wire therefore carries `TableCell[][]` and no coordinates: each end names its own
+// corner.
+//
+// A row 0 is A header, on both sides, which is the model's own rule (`table.ts`
+// §`allRows`): whichever row holds index 0 is the header. So a `<table>` with no `<th>`
+// promotes its first row, and a copied rectangle's first row is the header of what it
+// pastes.
+import { DOMParser as PMDOMParser, DOMSerializer, Fragment, Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { islandMinter } from './islands.js';
+import { inlineSchema } from './schema.js';
+import { ALIGNS, cellContent, cellFromDoc, emptyCell, normalizeTable } from './table.js';
+import { decode } from './decode.js';
+/** The two keys, spelled once: a reader and a writer that disagreed about which holds
+ *  the table would each work alone and never round-trip. */
+const HTML = 'text/html';
+const PLAIN = 'text/plain';
+// ── Reading a table in ──────────────────────────────────────────────────────
+/**
+ * One cell from its `<td>` / `<th>`. The inline schema is the whole normalization: it
+ * declares one paragraph, no containers and no islands, so a cell holding blocks
+ * flattens to its text and an image in one drops out rather than leaving a slot char
+ * behind. Whitespace collapses and the ends trim, which is PM's own parse.
+ */
+function cellFromDOM(dom) {
+    const para = PMDOMParser.fromSchema(inlineSchema).parse(dom, {
+        topNode: inlineSchema.nodes.paragraph.create()
+    });
+    return cellFromDoc(inlineSchema.nodes.doc.create(null, para), emptyCell());
+}
+/** A column's alignment off its header cell, which is where a pipe table's delimiter
+ *  row puts it. Anything else (`start`, `justify`, absent) is `none`. */
+function alignFromDOM(dom) {
+    const raw = (dom.getAttribute('align') ??
+        dom.style?.textAlign ??
+        '').toLowerCase();
+    return ALIGNS.includes(raw) ? raw : 'none';
+}
+/**
+ * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
+ * rectangle, so a table with one arrives with the rows below it short and
+ * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
+ * covers, so the columns after it keep their index.
+ *
+ * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
+ * reader is about to flatten, not to a rank of this one.
+ */
+export function tableFromDOM(dom) {
+    const rows = [];
+    const aligns = [];
+    for (const tr of dom.querySelectorAll('tr')) {
+        if (tr.closest('table') !== dom)
+            continue;
+        const cells = [];
+        for (const box of tr.children) {
+            if (box.tagName !== 'TD' && box.tagName !== 'TH')
+                continue;
+            if (!rows.length)
+                aligns.push(alignFromDOM(box));
+            cells.push(cellFromDOM(box));
+            const span = Number(box.getAttribute('colspan')) || 1;
+            for (let i = 1; i < span; i++) {
+                if (!rows.length)
+                    aligns.push('none');
+                cells.push(emptyCell());
+            }
+        }
+        rows.push(cells);
+    }
+    const [header = [], ...body] = rows;
+    return normalizeTable({ header, rows: body, aligns });
+}
+/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
+ *  one: a clipboard holding a table among other blocks is a document paste, and only a
+ *  surface that takes nothing but a table (a cell) reads it this way. */
+export function tableFromClipboard(data) {
+    const html = data?.getData(HTML);
+    if (!html || !/<table[\s>]/i.test(html))
+        return undefined;
+    const dom = new DOMParser().parseFromString(html, HTML).querySelector('table');
+    return dom ? tableFromDOM(dom) : undefined;
+}
+// ── Writing a rectangle out ─────────────────────────────────────────────────
+/** A cell's inline DOM, serialized by the schema that declares its marks, which is what
+ *  makes {@link cellFromDOM} its exact inverse. */
+function cellToDOM(cell, owner) {
+    const doc = decode(cellContent(cell), inlineSchema);
+    const line = doc.firstChild;
+    return DOMSerializer.fromSchema(inlineSchema).serializeFragment(line ? line.content : Fragment.empty, { document: owner });
+}
+/**
+ * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
+ * a `<th>` row whatever row of the source it came from, that being the row index 0 a
+ * paste lands it at.
+ */
+export function tableToDOM(block, aligns, owner) {
+    const table = owner.createElement('table');
+    block.forEach((cells, r) => {
+        const tr = owner.createElement('tr');
+        cells.forEach((cell, c) => {
+            const box = owner.createElement(r === 0 ? 'th' : 'td');
+            const align = aligns[c] ?? 'none';
+            if (align !== 'none')
+                box.style.textAlign = align;
+            box.appendChild(cellToDOM(cell, owner));
+            tr.appendChild(box);
+        });
+        table.appendChild(tr);
+    });
+    return table;
+}
+/** A cell's text as one pipe-table field: the delimiter escaped, since a `|` inside a
+ *  cell would otherwise open a column that is not there. Marks are dropped, markdown
+ *  being the lossy arm. */
+const pipeCell = (cell) => cell.text.replaceAll('|', '\\|');
+/**
+ * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
+ * table and what markdown carries. The delimiter follows the first row for the reason
+ * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
+ */
+export function tableToPipe(block, aligns) {
+    const width = block[0]?.length ?? 0;
+    const rule = Array.from({ length: width }, (_, c) => {
+        const align = aligns[c] ?? 'none';
+        if (align === 'center')
+            return ':---:';
+        return align === 'left' ? ':---' : align === 'right' ? '---:' : '---';
+    });
+    const line = (cells) => `| ${cells.join(' | ')} |`;
+    const [head = [], ...body] = block;
+    return [line(head.map(pipeCell)), line(rule), ...body.map((row) => line(row.map(pipeCell)))].join('\n');
+}
+/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
+ *  over a selection its own surface holds, so the rectangle arrives already cut out and
+ *  claiming the event is the caller's. */
+export function writeRectangle(data, block, aligns, owner) {
+    data.setData(HTML, tableToDOM(block, aligns, owner).outerHTML);
+    data.setData(PLAIN, tableToPipe(block, aligns));
+}
+// ── The paste door ──────────────────────────────────────────────────────────
+/** The `<table>` rule: a clipboard table becomes the island the model already holds
+ *  rather than the paragraph its text flattens to. `id` is left empty for
+ *  {@link stampIslandIds}, a parse rule having no document to mint against. `loss` is
+ *  authored: what this reader produces is a pipe table, so markdown carries it whole. */
+function tableParseRule() {
+    return {
+        tag: 'table',
+        node: 'island_block',
+        getAttrs: (dom) => ({
+            id: '',
+            islandType: 'table',
+            props: tableFromDOM(dom),
+            loss: 'lossless'
+        })
+    };
+}
+/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
+ *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
+ *  through to the enclosing block. */
+export function tableClipboardParser(schema) {
+    return new PMDOMParser(schema, [tableParseRule(), ...PMDOMParser.fromSchema(schema).rules]);
+}
+/** An island node a parse rule produced, which is the only kind carrying no id. */
+const unstamped = (node) => (node.type.name === 'island_block' || node.type.name === 'island_inline') && !node.attrs.id;
+/** Mint an id for every island a paste is carrying. An id is part of the document's
+ *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
+ *  pasted island with none reaches the store as an insert nothing can name afterwards.
+ *  One minter for the whole slice, or a paste placing two tables hands them one id. */
+export function stampIslandIds(slice, doc) {
+    const mint = islandMinter(doc);
+    const walk = (fragment) => {
+        const out = [];
+        fragment.forEach((node) => {
+            const next = node.content.size ? node.copy(walk(node.content)) : node;
+            out.push(unstamped(next) ? next.type.create({ ...next.attrs, id: mint() }, next.content) : next);
+        });
+        return Fragment.fromArray(out);
+    };
+    return new Slice(walk(slice.content), slice.openStart, slice.openEnd);
+}
+/**
+ * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
+ * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
+ * because what a `<table>` in the DOM means is a question only the clipboard asks — the
+ * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
+ * where an island is already a node and a `<table>` is the chrome drawing one.
+ */
+export function tableClipboardPlugin(schema) {
+    const parser = tableClipboardParser(schema);
+    return new Plugin({
+        props: {
+            clipboardParser: parser,
+            transformPasted: (slice, view) => stampIslandIds(slice, view.state.doc)
+        }
+    });
+}

package/dist/core/codec/code.d.ts

@@ -6,7 +6,7 @@ import { type Command } from 'prosemirror-state';
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
  * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
- * otherwise splits the ITEM in two, each half holding a code block. Every command
+ * otherwise splits the item in two, each half holding a code block. Every command
  * here declines outside a code block, so the list links keep the keys elsewhere.
  */
 export declare function codeKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/code.js

@@ -16,7 +16,7 @@ function codeBlockAt(state) {
 /**
  * Start offsets of the lines the range `[f, t)` covers, in document order.
  *
- * A line whose start IS `t` is excluded on a non-empty range: a selection ending at
+ * A line whose start is `t` is excluded on a non-empty range: a selection ending at
  * a line start does not reach into that line, the editor convention (else selecting
  * whole lines by dragging to the next line's start indents one line too many).
  */
@@ -44,7 +44,7 @@ function outdentWidth(text, s) {
 }
 /**
  * Tab in a code block: insert one indent unit, or indent every covered line when the
- * selection spans a newline. A single-line selection is REPLACED by the unit: Tab
+ * selection spans a newline. A single-line selection is replaced by the unit: Tab
  * types, the way any other key does.
  */
 const indentInCode = (state, dispatch) => {
@@ -75,7 +75,7 @@ const indentInCode = (state, dispatch) => {
 /**
  * Shift-Tab in a code block: remove one indent level from every covered line.
  *
- * Declines when no covered line carries an indent, so the key is NOT swallowed: it
+ * Declines when no covered line carries an indent, so the key is not swallowed: it
  * falls through to the list link and then out of the leaf, which is the body's
  * keyboard exit from inside a code block (VISUAL_EDITOR §Chrome).
  */
@@ -104,7 +104,7 @@ const outdentInCode = (state, dispatch) => {
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
  * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
- * otherwise splits the ITEM in two, each half holding a code block. Every command
+ * otherwise splits the item in two, each half holding a code block. Every command
  * here declines outside a code block, so the list links keep the keys elsewhere.
  */
 export function codeKeymap(schema) {

package/dist/core/codec/decode.d.ts

@@ -9,7 +9,7 @@ interface DecodeOpts {
     plaintext?: boolean;
 }
 /**
- * A `Content` as READ-ONLY DOM: decode under `schema`, then the nodes' own `toDOM`.
+ * A `Content` as read-only DOM: decode under `schema`, then the nodes' own `toDOM`.
  * The rendering half of the codec's job with no editing attached (no PM view, no
  * plugins, no `contenteditable`) for chrome that must show content in the same
  * mark vocabulary a leaf edits it in (the tips card). A second renderer over the

package/dist/core/codec/decode.js

@@ -4,7 +4,7 @@
 // prefix (`list_item`/`quote` → lists/blockquote), select the block node by
 // `kind`, apply marks over their `[start,end)` USV ranges (PM splits inline nodes
 // at mark boundaries), and lower island slots to leaf nodes (inline in a `para`
-// line, block on an `island` line). Anchors are NOT applied here; they are
+// line, block on an `island` line). Anchors are not applied here; they are
 // decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
 // code point so an astral char is one unit, never a surrogate half.
 import { DOMSerializer } from 'prosemirror-model';
@@ -24,7 +24,7 @@ export function usvLength(s) {
     return n;
 }
 /**
- * A `Content` as READ-ONLY DOM: decode under `schema`, then the nodes' own `toDOM`.
+ * A `Content` as read-only DOM: decode under `schema`, then the nodes' own `toDOM`.
  * The rendering half of the codec's job with no editing attached (no PM view, no
  * plugins, no `contenteditable`) for chrome that must show content in the same
  * mark vocabulary a leaf edits it in (the tips card). A second renderer over the
@@ -92,7 +92,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             continue;
         }
         const here = path[depth];
-        // `ContentContainer` is an OPEN set: a bare `here.container === 'x'` does not
+        // `ContentContainer` is an open set: a bare `here.container === 'x'` does not
         // narrow, so the two arms this schema builds are claimed by the boundary's
         // guard and a literal check, and everything else is an unknown the inert
         // wrapper carries (CODEC §Open sets); no branch degrades silently.
@@ -106,7 +106,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
                 const c = atDepth(leaves[j], depth);
                 if (!c || !isListItemContainer(c) || c.ordered !== ordered || c.start !== start)
                     break;
-                // An ordinal reset is an ADJACENT SIBLING list (content preserves the
+                // An ordinal reset is an adjacent sibling list (content preserves the
                 // shape): merging it here would re-encode `[0,1,0]` as `[0,1,2]`,
                 // breaking the decode round-trip on the first edit.
                 if (c.ordinal < prevOrd)
@@ -131,7 +131,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             continue;
         }
         // quote and every unknown container share one shape: a wrapper over the run
-        // of leaves carrying the IDENTICAL container here (identity by `containerKey`,
+        // of leaves carrying the identical container here (identity by `containerKey`,
         // so two adjacent unknowns differing only in `attrs` stay two wrappers).
         const key = containerKey(here);
         let j = i + 1;
@@ -165,7 +165,7 @@ function containerKey(c) {
     return 'attrs' in c ? `${c.container}\u0000${JSON.stringify(c.attrs)}` : c.container;
 }
 /** A single leaf block node (para/heading/code/rule/island, or an unknown kind
- * carried on a paragraph) from its segments. `kind` is an OPEN set, so the two
+ * carried on a paragraph) from its segments. `kind` is an open set, so the two
  * payload-carrying arms read through the boundary's guards; the payload-free arms
  * compare literally, and anything left is unknown. */
 function makeLeaf(schema, leaf, marks, cursor) {
@@ -191,13 +191,13 @@ function makeLeaf(schema, leaf, marks, cursor) {
     if (isHeadingLine(line)) {
         return schema.nodes.heading.create({ level: line.level }, inline);
     }
-    // An unknown kind renders as a paragraph AND rides on it, so it re-encodes
+    // An unknown kind renders as a paragraph and rides on it, so it re-encodes
     // verbatim rather than flattening to `para` on the field's first edit.
     const unknown = line.kind === 'para' ? null : { kind: line.kind, attrs: 'attrs' in line ? line.attrs : null };
     return schema.nodes.paragraph.create({ unknown }, inline);
 }
 /** Consume the next island entry as PM node attrs (text-order matched to slots):
- *  the WHOLE entry, `loss` included, which an island edit has to write back
+ *  the whole entry, `loss` included, which an island edit has to write back
  *  (`islands.ts`). A slot with no entry behind it is a malformed content; the empty
  *  attrs keep the decode total rather than throwing on a read. */
 function islandAttrs(cursor) {

package/dist/core/codec/encode.d.ts

@@ -27,7 +27,7 @@ export interface Scan {
     usvEnd: number;
 }
 /**
- * Walk a PM document once, producing the content projection AND the position-map
+ * Walk a PM document once, producing the content projection and the position-map
  * runs (they share the traversal so they can never disagree). This is the single
  * source both `pmToContent` and the position map draw from.
  */
@@ -40,14 +40,14 @@ interface LowerOpts {
         id: string;
         pos: number;
     }[];
-    /** Anchor decoration positions after the edit, in FINAL (new) USV coords. */
+    /** Anchor decoration positions after the edit, in final (new) USV coords. */
     newAnchors?: {
         id: string;
         pos: number;
     }[];
 }
 /**
- * One old→new content edit with the text splice it implies. BOTH sides are content,
+ * One old→new content edit with the text splice it implies. Both sides are content,
  * never a PM doc: the projection of the new doc (`pmToContent`) is the caller's to
  * hold, because a doc-taking overload re-walks the whole tree, once per keystroke,
  * for a value the caller has in hand.
@@ -56,7 +56,7 @@ interface LowerOpts {
  * and the commit path holds the edit across the lowering. `contentEdit` being its
  * only constructor is what keeps a `delta` from disagreeing with the contents it
  * was diffed from; `lower` is where a slot inside that splice moves to the island
- * channel, so this `delta` is the RAW splice, not always the one committed.
+ * channel, so this `delta` is the raw splice, not always the one committed.
  */
 export interface ContentEdit {
     readonly oldRt: Content;

package/dist/core/codec/encode.js

@@ -1,4 +1,5 @@
-import { mapPos, isAnchorMark } from '@quillmark/wasm';
+import { isAnchorMark } from '@quillmark/wasm';
+import { core } from '../lifecycle.js';
 import { codePoints, usvLength } from './decode.js';
 import { ISLAND_SLOT, islandEntryFromNode } from './islands.js';
 import { contentDescriptorFromPM, descriptorOf, markKey } from './marks.js';
@@ -9,7 +10,7 @@ function appendText(acc, s) {
     acc.usvEnd += usvLength(s);
 }
 /**
- * Walk a PM document once, producing the content projection AND the position-map
+ * Walk a PM document once, producing the content projection and the position-map
  * runs (they share the traversal so they can never disagree). This is the single
  * source both `pmToContent` and the position map draw from.
  */
@@ -49,7 +50,7 @@ function scanBlock(acc, node, nodePos, containers) {
         case 'paragraph':
         case 'heading': {
             // One kind value per block: the opening line and its hard-break
-            // continuations read the SAME object, so they cannot disagree.
+            // continuations read the same object, so they cannot disagree.
             const kind = textblockKind(node);
             beginLine(acc, contentStart, containers, kind);
             scanInline(acc, node, contentStart, containers, kind);
@@ -255,7 +256,7 @@ function diffLines(oldRt, newRt) {
 }
 /** A line minus its `containers` / `continues` envelope: exactly `setKind`'s
  * payload, which the boundary names `ContentLineKind`. Lifting it whole is what
- * keeps this arm-agnostic: `kind` is an OPEN set, so an arm-by-arm switch would
+ * keeps this arm-agnostic: `kind` is an open set, so an arm-by-arm switch would
  * have to guess at the unknown arm's payload and would drift on every arm
  * upstream adds. */
 function kindPart(l) {
@@ -285,14 +286,14 @@ function kindKey(l) {
 }
 /**
  * Split the edit's islands off the text splice. `applyChange` throws
- * `IslandSlotInInsert` on a `delta` that types a slot, so a slot NEVER rides the
+ * `IslandSlotInInsert` on a `delta` that types a slot, so a slot never rides the
  * delta: every slot inside the splice's inserted region is stripped from it and
  * placed by `{ op: 'insert', at }`, which carries the backing entry in the same
  * op. Every other island kept its slot, so a changed payload is `{ op: 'set' }`,
- * addressed by the id both sides carry. A DELETED island needs no op at all: the
+ * addressed by the id both sides carry. A deleted island needs no op at all: the
  * delta that removes its slot drops the entry.
  *
- * `at` is the slot's position in the FINAL text: inserts apply left to right, so
+ * `at` is the slot's position in the final text: inserts apply left to right, so
  * by the time the k-th lands, the k slots before it are back in place.
  *
  * The pairing is positional for `insert` and by id for `set`, which is what each
@@ -337,7 +338,7 @@ function slotPositions(text) {
     }
     return out;
 }
-/** The splice's inserted region `[start, end)` in FINAL coords. `diffText` emits
+/** The splice's inserted region `[start, end)` in final coords. `diffText` emits
  *  one `[retain?][delete?][insert?][retain?]`, so the leading retain is where the
  *  insert lands and its length is how far it reaches. */
 function insertedRegion(delta) {
@@ -349,7 +350,7 @@ function insertedRegion(delta) {
     return { start, end: start + (insert ? usvLength(insert.insert) : 0) };
 }
 /** The delta with every island slot removed from its insert, or `undefined` when
- *  that leaves nothing but retains. Retain/delete arithmetic reads the OLD text,
+ *  that leaves nothing but retains. Retain/delete arithmetic reads the old text,
  *  so dropping inserted characters leaves the rest of the splice intact. */
 function withoutSlots(delta) {
     const ops = [];
@@ -374,7 +375,7 @@ function withoutSlots(delta) {
  * A post-delta position carried through the bundle's island inserts, which move
  * text exactly as the delta does and rebase marks by the same rule (start-assoc
  * `after`, end-assoc `before`; an anchor is a point and holds `before`). Ascending
- * `at`s apply left to right, so each comparison reads the RUNNING position.
+ * `at`s apply left to right, so each comparison reads the running position.
  */
 function shiftPastIslands(pos, insertedAt, assoc) {
     let p = pos;
@@ -386,7 +387,9 @@ function shiftPastIslands(pos, insertedAt, assoc) {
 /** Formatting/unknown marks → add/remove ops; anchors → add/removeAnchor by id. */
 function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
     const ops = [];
-    // Rebase old marks through BOTH text-moving channels to final coords, exactly
+    // Read the gate once per diff rather than once per mark.
+    const { mapPos } = core();
+    // Rebase old marks through both text-moving channels to final coords, exactly
     // as `applyChange` does internally (start assoc `after`, end assoc `before`).
     const rebase = (pos, assoc) => shiftPastIslands(delta ? mapPos(delta, pos, assoc) : pos, insertedAt, assoc);
     // Group both sides by descriptor key (excluding anchors).

package/dist/core/codec/field.d.ts

@@ -4,7 +4,7 @@ import { EditorView } from 'prosemirror-view';
 import type { Document, Content, Addr, Quill } from '@quillmark/wasm';
 import type { EditorErrorHandler } from '../errors.js';
 import { type TableChromeStrings } from './table-view.js';
-import { type SlashItem, type SlashState, type SlashStrings } from './slash.js';
+import { type SlashState } from './slash.js';
 /** Options for {@link createField}. */
 export interface CreateFieldOpts {
     doc: Document;
@@ -20,24 +20,22 @@ export interface CreateFieldOpts {
     plaintext?: boolean;
     /** Suppress the markdown-shorthand input rules. */
     noInputRules?: boolean;
-    /** The island chrome's wording, read LIVE (per render) so a consumer swapping
+    /** The island chrome's wording, read live (per render) so a consumer swapping
      *  locale mid-session re-renders rather than freezing it at mount. Absent leaves
      *  the package's English; an inline leaf never asks (it holds no island). */
     tableStrings?: () => TableChromeStrings;
-    /** The slash menu's wording, read live for the same reason. */
-    slashStrings?: () => SlashStrings;
     /**
      * The slash menu's live state, or `undefined` when it is closed: the channel the
      * chrome draws from (`visual/SlashMenu.svelte`).
      *
-     * Its PRESENCE is what mounts the menu at all. The trigger and its keys are the
+     * Its presence is what mounts the menu at all. The trigger and its keys are the
      * leaf's, but a surface only a keyboard can reach (claiming Enter, Escape and the
      * arrows with nothing on screen) is worse than no surface, so the door exists
      * exactly where something can draw it. A constrained inline leaf never has one:
      * it holds no island and no block to convert.
      */
     onSlash?(state: SlashState | undefined): void;
-    /** Accessible name → `aria-label` on the `contenteditable`. For a leaf NOTHING
+    /** Accessible name → `aria-label` on the `contenteditable`. For a leaf nothing
      * else names: an array element (the field label plus its 1-based index), the
      * card body (no visible label at all). A leaf with a field label takes
      * `labelledBy` instead: `for` cannot reach a `contenteditable`, which is not a
@@ -48,7 +46,7 @@ export interface CreateFieldOpts {
     /** The parked `description` → `aria-describedby`; announced after the name. */
     describedBy?: string;
     /** Ghost text shown on the empty leaf: the resolved `default:` a field ghosts,
-     * or a body's invitation. The INITIAL value; {@link
+     * or a body's invitation. The initial value; {@link
      * FieldController.setPlaceholder} moves it after mount. Empty/absent
      * shows no ghost. */
     placeholder?: string;
@@ -56,7 +54,7 @@ export interface CreateFieldOpts {
     /** Fired with the new USV caret after an edit or a selection move. */
     onCaretMove?(addr: Addr, pos: number): void;
     /**
-     * Fired after an edit COMMITTED to the document: the leaf's change signal, and
+     * Fired after an edit committed to the document: the leaf's change signal, and
      * the reason it is not `onCaretMove`. That one also fires on a bare selection
      * move, so a host driving a recompile off it recompiles on every arrow key.
      *
@@ -74,7 +72,7 @@ export interface FieldController {
     /** The mounted `container`: the leaf's element, for a caller that has to reach the
      *  DOM the view sits in (the arrival wash, `core/bloom.ts`) rather than re-find it. */
     readonly el: HTMLElement;
-    /** Place the caret at USV `pos` (preview onCaretPick → usvToPM → here). */
+    /** Place the caret at USV `pos` (preview onPick → usvToPM → here). */
     setCaret(pos: number): void;
     /** External content change → re-hydrate this leaf (gated by reconcile). */
     applyExternal(): void;
@@ -83,7 +81,7 @@ export interface FieldController {
      * its new kind's wording without remounting, which it must not do (the leaf key
      * is the card's session id, so a remount would cost the caret).
      *
-     * Refreshes the decoration WITHOUT a transaction: a placeholder is chrome, and
+     * Refreshes the decoration without a transaction: a placeholder is chrome, and
      * a transaction would fire `onCaretMove` at a moment the caret did not move.
      */
     setPlaceholder(text: string | undefined): void;
@@ -103,14 +101,14 @@ export interface FieldController {
     /** Ids of the anchors within USV range `[from, to]`: a selection's anchor state. */
     anchorsInRange(from: number, to: number): string[];
     /**
-     * Move the slash menu's cursor onto item `id`: what a POINTER entering an item
-     * calls. The keyboard cursor and the pointer's highlight are one state, so the
+     * Move the slash menu's cursor onto the command `name`: what a pointer entering an
+     * item calls. The keyboard cursor and the pointer's highlight are one state, so the
      * chrome moves the one the keys already drive rather than painting a second.
      */
-    slashFocus(id: string): void;
-    /** Run slash item `id` (a click on one): the same path Enter takes. A no-op with
-     *  no menu open, which is the state a stale click lands in. */
-    slashPick(id: string): void;
+    slashFocus(name: string): void;
+    /** Run the command `name` (a click on its item): the same path Enter takes. A no-op
+     *  with no menu open, which is the state a stale click lands in. */
+    slashPick(name: string): void;
     /** The current PM selection as a USV `{ from, to }` range (the boundary currency). */
     selectionRange(): {
         from: number;
@@ -123,9 +121,9 @@ export interface FieldController {
  * of {@link FieldController}: they are PM internals, and a consumer's contract is the
  * controller's verbs. The format popover is the one caller and it needs both:
  * `view` to name the leaf's own document, `focusedView` to act on wherever the caret
- * actually is, which inside a table island is a NESTED cell view (`table-view.ts`).
+ * actually is, which inside a table island is a nested cell view (`table-view.ts`).
  * The two being different is exactly what tells the popover to withhold its
- * `anchor` button: an anchor is the FIELD's coordinate space, and a cell is not in it.
+ * `anchor` button: an anchor is the field's coordinate space, and a cell is not in it.
  */
 export interface LeafViews {
     view: EditorView;
@@ -144,24 +142,21 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * leaf-specific plugins (`afterHistory`: the addressed leaf passes its
  * anchor-position plugin; a by-value array element passes none), the
  * markdown-shorthand input rules, then the field keymap over the base keymap, and
- * last the two that answer to a caret or a selection BESIDE a block: the gap cursor
+ * last the two that answer to a caret or a selection beside a block: the gap cursor
  * and {@link pastAtomPlugin}.
  *
  * A `plaintext` field carries no marks (decode strips them, the keymap suppresses
  * Mod-b/i/u), so it also skips the input rules: `inlineSchema` still declares the
- * mark types, so a `**bold**` rule would apply a strong mark AND eat the literal
- * delimiters. The inline schema has no block nodes, so those rules are the ONLY
+ * mark types, so a `**bold**` rule would apply a strong mark and eat the literal
+ * delimiters. The inline schema has no block nodes, so those rules are the only
  * ones it would add: skip all.
  */
 export declare function proseLeafPlugins(schema: Schema, opts: {
     inline: boolean;
     plaintext: boolean;
-    /** The slash menu's model and its report channel; absent mounts no menu and
-     *  leaves Enter/Escape/the arrows to the links below (`keymap.ts`). */
-    slash?: {
-        items: () => SlashItem[];
-        onState: (state: SlashState | undefined) => void;
-    };
+    /** The slash menu's report channel; absent mounts no menu and leaves
+     *  Enter/Escape/the arrows to the links below (`keymap.ts`). */
+    slash?: (state: SlashState | undefined) => void;
     noInputRules?: boolean;
     /** Read live, not captured: the ghost can move after mount
      *  ({@link FieldController.setPlaceholder}), and a re-hydration rebuilds this