@quillmark/svelte 0.2.0 → 0.3.0

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

@@ -10,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.
  */
@@ -50,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);
@@ -256,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) {
@@ -286,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
@@ -338,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) {
@@ -350,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 = [];
@@ -375,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;
@@ -389,7 +389,7 @@ function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
     const ops = [];
     // 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
+    // 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.
      *
@@ -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

package/dist/core/codec/field.js

@@ -6,11 +6,11 @@
 //   (b) lower the tr to a `ChangeBundle` (or `overwrite` for a field not yet at
 //       content rest, which has nothing to splice),
 //   (c) commit via `doc.applyChange(addr, bundle)`,
-//   (d) fire `onChange` when the transaction COMMITTED, then `onCaretMove` with
+//   (d) fire `onChange` when the transaction committed, then `onCaretMove` with
 //       the new USV caret, which a bare selection move fires on its own.
 // On an `applyChange` throw the optimistic PM state stays and the failure reports
 // through `onError`: never a crash. Caret continuity across own-edits is the PM
-// `StepMap`; an EXTERNAL content change re-hydrates through `applyExternal`, gated
+// `StepMap`; an external content change re-hydrates through `applyExternal`, gated
 // by `reconcile`.
 import { baseKeymap, toggleMark } from 'prosemirror-commands';
 import { gapCursor } from 'prosemirror-gapcursor';
@@ -19,6 +19,7 @@ import { keymap } from 'prosemirror-keymap';
 import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 import { reportError, errorMessage } from '../errors.js';
+import { tableClipboardPlugin } from './clipboard.js';
 import { decode } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 import { lower, pmToContent, contentEdit } from './encode.js';
@@ -28,7 +29,7 @@ import { inputRulesPlugin } from './inputrules.js';
 import { bodyKeymap } from './keymap.js';
 import { blockSchema, inlineSchema } from './schema.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
-import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashItems, slashPlugin } from './slash.js';
+import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
 /** Plugin-held anchor positions (PM coords), mapped through every edit's `StepMap`
  * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection). */
@@ -62,8 +63,8 @@ function anchorPlugin(seed) {
  *
  * Bound rather than verbatim, because the storage form is not the leaf's business
  * and the verbatim read cannot answer it alone. A field the editor committed rests
- * as `Content`; a field a markdown parse left rests as the authored STRING, and
- * what that string MEANS is the declared type's to say: `richtext` is markdown,
+ * as `Content`; a field a markdown parse left rests as the authored string, and
+ * what that string means is the declared type's to say: `richtext` is markdown,
  * `plaintext` is literal text, and reading one as the other silently eats every
  * `*` the author typed. */
 function readLeaf(reader, addr) {
@@ -77,9 +78,9 @@ export function emptyContent() {
 /** Whether ops may commit here: the stored value is a `Content` object, so
  * `applyChange` splices exactly the content the leaf read and PM is showing.
  *
- * The two other rest forms both take `overwrite` instead. An UNSET field (`undefined`;
+ * The two other rest forms both take `overwrite` instead. An unset field (`undefined`;
  * a default-only richtext field before its first edit) has nothing to splice.
- * An AUTHORED STRING is the trap: `applyChange` reads it as markdown whatever the
+ * An authored string is the trap: `applyChange` reads it as markdown whatever the
  * declared type is, so on a `plaintext` field its pre-image is not the content the
  * leaf read and a delta computed against that content lands at the wrong offsets.
  * Installing over it costs nothing either way, since content-only marks do not
@@ -119,15 +120,14 @@ export function createField(opts) {
     // The ghost's live cell: the placeholder plugin reads it per pass, so moving it
     // is an assignment plus a re-render rather than a rebuilt plugin stack.
     let placeholderText = opts.placeholder;
-    // The views nested INSIDE this leaf: one per table cell (`table-view.ts`). The
+    // The views nested inside this leaf: one per table cell (`table-view.ts`). The
     // leaf holds the set because chrome asks the leaf, not the island, which view
     // holds the caret: the format popover raises over a cell exactly as over the
     // body, and only the leaf knows both.
     const nested = new Set();
-    // The menu's offers, derived from the wording per read: the chrome names an item
-    // and the codec runs it, so a locale swap changes the labels and not the picks.
-    const menuItems = () => slashItems(opts.slashStrings?.() ?? DEFAULT_SLASH_STRINGS);
-    const slash = !inline && opts.onSlash ? { items: menuItems, onState: opts.onSlash } : undefined;
+    // The menu's report channel, and the whole of what a leaf holds of it: the
+    // vocabulary is the codec's own constant (`slash.ts`), not a wording to derive.
+    const slash = inline ? undefined : opts.onSlash;
     const state = buildState(reconciler.last);
     index = buildLineIndex(state.doc);
     view = new EditorView(container, {
@@ -154,7 +154,7 @@ export function createField(opts) {
             const next = view.state.apply(tr);
             view.updateState(next); // (a) optimistic
             index = buildLineIndex(next.doc);
-            // Commit a content edit OR an anchor mutation. An anchor insert/remove is
+            // Commit a content edit or an anchor mutation. An anchor insert/remove is
             // zero-width, so `docChanged` is false: the `anchorKey` meta is what
             // routes it through the same commit path (the diff emits the anchor op).
             if (tr.docChanged || tr.getMeta(anchorKey)) {
@@ -203,7 +203,7 @@ export function createField(opts) {
     // Returns whether anything landed: the caller's change signal, which must not
     // be a property of which branch the commit took.
     function commitEdit(oldRt, newDoc) {
-        // The projection and its text splice, each computed ONCE per keystroke: the gate
+        // The projection and its text splice, each computed once per keystroke: the gate
         // below, both overwrite fallbacks, and `lower` all read this one `edit`.
         const edit = contentEdit(oldRt, pmToContent(newDoc));
         try {
@@ -226,7 +226,7 @@ export function createField(opts) {
             return true;
         }
         catch (e) {
-            // Bound the damage: an op path the gates missed leaves the store STALE
+            // Bound the damage: an op path the gates missed leaves the store stale
             // while PM keeps the edit; and because the reconciler then re-diffs
             // from that stale content, every later edit re-throws and the field
             // silently stops persisting. Install the full projection instead
@@ -256,7 +256,7 @@ export function createField(opts) {
     }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
-    /** Anchor positions in the CURRENT (new) doc, as USV. */
+    /** Anchor positions in the current (new) doc, as USV. */
     function readAnchorsUsv(newDoc) {
         return heldAnchors().map((a) => ({ id: a.id, pos: pmToUsv(index, a.pos) }));
     }
@@ -326,13 +326,13 @@ export function createField(opts) {
             })
                 .map((a) => a.id);
         },
-        slashFocus(id) {
+        slashFocus(name) {
             if (slash)
-                focusSlashItem(view, id, slash.items());
+                focusSlashItem(view, name);
         },
-        slashPick(id) {
+        slashPick(name) {
             if (slash)
-                runSlashItem(view, id);
+                runSlashItem(view, name);
         },
         selectionRange() {
             const { from, to } = view.state.selection;
@@ -365,13 +365,13 @@ export function createField(opts) {
  * 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 function proseLeafPlugins(schema, opts) {
@@ -380,21 +380,22 @@ export function proseLeafPlugins(schema, opts) {
         list.push(slashPlugin(opts.slash));
     if (!opts.noInputRules && !opts.plaintext)
         list.push(inputRulesPlugin(schema));
-    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, opts.slash?.items)));
+    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // Both answer to a selection over an ATOM, which only a block leaf holds: an
-    // inline leaf is one textblock with no island and no gap to put a cursor in.
+    // All three answer to something only a block leaf holds: an inline leaf is one
+    // textblock with no island, no gap to put a cursor in, and nowhere for a pasted
+    // table to land.
     if (!opts.inline)
-        list.push(gapCursor(), pastAtomPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), tableClipboardPlugin(schema));
     if (opts.placeholder)
         list.push(placeholderPlugin(opts.placeholder));
     return list;
 }
 /**
- * A printable key over a selected atom writes PAST it. A selection is the subject
+ * A printable key over a selected atom writes past it. A selection is the subject
  * of the next command, never a thing armed for
  * replacement: Backspace deletes it, Mod-C copies it, and a character lands beside
- * it. A BLOCK island takes a new paragraph after it, an INLINE one the caret after
+ * it. A block island takes a new paragraph after it, an inline one the caret after
  * the image in the same line: one rule, both node types.
  *
  * PM routes text input over a non-`TextSelection` through `handleTextInput` before
@@ -461,13 +462,13 @@ function placeholderPlugin(read) {
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
  * suppressed inline.
  *
- * Tab forks on the leaf's ROLE, not on the caret's position. An inline/plaintext
+ * Tab forks on the leaf's role, not on the caret's position. An inline/plaintext
  * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
  * keymap (VISUAL_EDITOR §Settled and open). A block-schema body is a document: Tab
  * is structural, a chain each nested surface prepends to (`keymap.ts`). One key
  * never means two things within one surface.
  */
-function editorKeymap(schema, inline, plaintext, slashItems) {
+function editorKeymap(schema, inline, plaintext, slash) {
     const map = {
         'Mod-z': undo,
         'Mod-y': redo,
@@ -487,7 +488,7 @@ function editorKeymap(schema, inline, plaintext, slashItems) {
     }
     else {
         // Each binding falls through to `baseKeymap` when no link claims the key.
-        Object.assign(map, bodyKeymap(schema, slashItems));
+        Object.assign(map, bodyKeymap(schema, slash));
     }
     return map;
 }

package/dist/core/codec/index.js

@@ -1,9 +1,9 @@
 // The codec barrel: the bidirectional bridge between one content field (`Content`)
-// and one ProseMirror document (CODEC). Decode (content → PM), lower (PM tr → a
+// and one ProseMirror document (CODEC.md). Decode (content → PM), lower (PM tr → a
 // `ChangeBundle` for `applyChange`), the USV↔PM position map, and the `createField`
 // prose leaf. Consumed by the VisualEditor and the codec test suite.
 // ProseMirror's structural base styles and the gap cursor's, then the retint of the
-// hues they mint. Imported HERE because `createField` is what mounts a view: a
+// hues they mint. Imported here because `createField` is what mounts a view: a
 // consumer reaching the codec directly gets them with it, and the order is what makes
 // the retint win.
 import 'prosemirror-view/style/prosemirror.css';
@@ -24,12 +24,9 @@ export { DEFAULT_SLASH_STRINGS } from './slash.js';
 export { blockSchema, inlineSchema } from './schema.js';
 // Decode / encode / positions (tests + VisualEditor).
 //
-// THE BARREL CARRIES WHAT HAS AN OFF-BARREL CALLER, and nothing else. The mark
-// algebra, the island bridge, the schema predicate, the `diff*` helpers,
-// `scanDoc`, `codePoints`: every one of them is reached by RELATIVE import
-// within `codec/`, so none of them is here. An export nothing imports is surface
-// that still has to stay honest; a symbol earns its line when a caller outside
-// this folder wants it.
+// The barrel carries what has an off-barrel caller, and nothing else. A symbol
+// reached only by relative import within `codec/` stays off it: an export nothing
+// imports is surface that still has to stay honest.
 export { decode, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';