@quillmark/svelte 0.27.0 → 0.28.0

package/dist/core/codec/field.js

@@ -1,18 +1,12 @@
-// The prose leaf: `createField` (VISUAL_EDITOR §Surface). One content field, one
-// PM `EditorState`/`EditorView`, wired to the WASM edit surface. It reads the
-// leaf's `Content`, decodes to a PM state, mounts a view + plugin stack (history,
-// keymap, input rules, the anchor-position plugin), and `dispatchTransaction`:
-//   (a) apply optimistically to the view,
-//   (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)`, or a `text` leaf's whole text
-//       through the typed writer,
-//   (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
-// by `reconcile` except where the hold it re-evaluates flips.
+// The prose leaf: `createField` (VISUAL_EDITOR §Surface). One content field, one PM view wired to
+// the WASM edit surface.
+//
+// `dispatchTransaction` applies the transaction optimistically, lowers it to a `ChangeBundle` (or
+// `overwrite` for a field not yet at content rest, which has nothing to splice), commits via
+// `doc.applyChange` (a `text` leaf's whole text through the typed writer), then fires `onChange` if
+// it committed and `onCaretMove`. A throw keeps the optimistic PM state and reports through
+// `onError`. An external change re-hydrates through `applyExternal`, gated by `reconcile` except
+// where the hold it re-evaluates flips.
 import { baseKeymap, toggleMark } from 'prosemirror-commands';
 import { gapCursor } from 'prosemirror-gapcursor';
 import { history, redo, undo } from 'prosemirror-history';
@@ -70,26 +64,18 @@ function anchorPlugin(seed) {
         }
     });
 }
-/** Read the leaf's `Content` for `addr`: `reader.getContent` (DOCUMENT_MODEL),
- * the schema-plane read that decodes through the codec the field's declared type
- * names. A field value, or the body `Content` when `addr.field` is absent, without
- * materializing the whole card. Reads are total over the field axis, so an absent
- * field, a default-only richtext field (e.g. `tag_line`, no stored value until
- * first edited), reads `undefined`; decode an empty content rather than crash, and
- * the first edit overwrites it. Only an out-of-range `addr.card` throws, unreachable
- * here: a removed card unmounts its keyed leaf before a stale index is read.
- *
- * 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,
- * `text` is literal text, and reading one as the other silently eats every `*` the
- * author typed. */
+/**
+ * Read the leaf's `Content` for `addr` through `reader.getContent` (DOCUMENT_MODEL): the body when
+ * `addr.field` is absent. Bound by the declared type rather than a verbatim read, since a string a
+ * markdown parse left means markdown for `richtext` and literal text for `text`; reading one as the
+ * other eats every `*` the author typed. An absent field (a default-only richtext field before its
+ * first edit) reads `undefined` and decodes empty; the first edit overwrites it. Only an
+ * out-of-range `addr.card` throws, unreachable since a removed card unmounts its keyed leaf.
+ */
 function readLeaf(reader, addr) {
     return reader.getContent(addr) ?? emptyContent();
 }
-/** The canonical empty `Content`: one empty `para` line. The empty a prose
- * leaf (or an array's prose element) seeds from. */
+/** The canonical empty `Content`: one empty `para` line. */
 export function emptyContent() {
     return { text: '', lines: [{ containers: [], kind: 'para' }], marks: [], islands: [] };
 }
@@ -97,24 +83,21 @@ export function emptyContent() {
 export function isEmptyContent(rt) {
     return contentEqual(rt, 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`;
- * a default-only richtext field before its first edit) has nothing to splice, and an
- * authored string nothing to lose: content-only marks do not survive markdown, so a
- * string carries no anchors to pay. A body always rests as `Content`. A `text` leaf
- * never asks: it commits through the writer ({@link createField}). */
+/**
+ * Whether ops may commit here: the stored value is a `Content` object, so `applyChange` splices
+ * exactly what PM shows. The other rest forms take `overwrite`: an unset field has nothing to
+ * splice, and an authored string carries no anchors to pay. A body always rests as `Content`; a
+ * `text` leaf commits through the writer ({@link createField}).
+ */
 function opsCommittable(doc, addr) {
     const stored = doc.getStored(addr);
     return stored !== null && typeof stored === 'object';
 }
-/** The naming attributes for the `contenteditable`, shared by every prose leaf
- * (`ProseValue` takes it too, so an addressed leaf and a by-value one name their
- * regions by one rule). `aria-labelledby` supersedes `aria-label`: a leaf carrying
- * both is the ambiguity where implementations disagree about which wins, and
- * `undefined` is returned whole when a leaf takes neither, since ProseMirror reads
- * the absence, not an empty object. */
+/**
+ * The naming attributes for the `contenteditable`, shared with `ProseValue`. `aria-labelledby`
+ * supersedes `aria-label`, and `undefined` is returned whole when a leaf takes neither, since
+ * ProseMirror reads the absence.
+ */
 export function proseAttributes(opts) {
     const attrs = {};
     if (opts.labelledBy)
@@ -141,13 +124,10 @@ export function createField(opts) {
     const { doc, addr, container } = opts;
     const inline = !!opts.inline;
     const plaintext = !!opts.plaintext;
-    // The declared type picks the schema, and the schema is the whole of what
-    // `plaintext` suppresses: no mark types to toggle, to paste in, or to mint a
-    // shorthand with (`schema.ts`).
+    // The declared type picks the schema; `plaintext` suppresses every mark (`schema.ts`).
     const schema = leafSchema({ plaintext, inline });
     const block = isBlockSchema(schema);
-    // Bound once and held: the reader is a `{quill, doc}` pair that reads live, so
-    // every read below sees the commit before it.
+    // Bound once: the reader reads live, so every read sees the commit before it.
     const reader = opts.quill.reader(doc);
     const writer = opts.quill.writer(doc);
     let fallback = opts.fallback;
@@ -164,13 +144,10 @@ export function createField(opts) {
     // The ghost's live cell: the ghost 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
-    // 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.
+    // The views nested inside this leaf, one per table cell (`table-view.ts`): chrome asks the leaf
+    // which view holds the caret.
     const nested = new Set();
-    // 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.
+    // The menu's report channel; the vocabulary is the codec's own constant (`slash.ts`).
     const slash = block ? opts.onSlash : undefined;
     // Judged of the value being mounted rather than read off a diagnostic: a routed set
     // can predate the value it arrives with, and `validation::not_plain` stands in for
@@ -183,13 +160,9 @@ export function createField(opts) {
     const seeded = buildState(reconciler.last);
     const state = seeded.state;
     index = seeded.index;
-    // The clearance PM's reveal keeps around the caret, in this leaf's own line box.
-    // Its default is 5px, which is a caret visible and unusable: the next line typed
-    // lands past the fold, the reason the preview's own scroll clears a target by the
-    // target's height (PREVIEW.md §"Follow-the-caret scroll"). Measured off the
-    // mounted box rather than restated from the rung, and dropped where the
-    // derivation is out of reach (jsdom), a fallback there being the scale written
-    // where `check:style` cannot read it.
+    // The clearance PM's reveal keeps around the caret, in this leaf's own line box: PM's 5px
+    // default leaves the next typed line past the fold. Measured off the mounted box and dropped
+    // where the derivation is out of reach (jsdom).
     const lineBox = Number.parseFloat(getComputedStyle(container).lineHeight);
     const clearance = Number.isFinite(lineBox) ? lineBox : undefined;
     // Prepended, so what the caller draws inside `container` (a held leaf's note)
@@ -211,9 +184,8 @@ export function createField(opts) {
                         nested.add(cellView);
                         return () => nested.delete(cellView);
                     },
-                    // A focus event does not bubble, so the leaf's own `focus` handler
-                    // never fires for a cell: without this the active address would not
-                    // follow a caret clicked straight into a table.
+                    // A focus event does not bubble, so the leaf's `focus` handler never fires
+                    // for a cell.
                     onCellFocus: () => opts.onFocus?.(addr),
                     clearance
                 })
@@ -230,25 +202,20 @@ export function createField(opts) {
             if (!held && (tr.docChanged || tr.getMeta(anchorKey)))
                 defaulted = false;
             view.updateState(next); // (a) optimistic
-            // One walk per structural change: the index and the projection the commit
-            // diffs both come off it. A selection-only transaction leaves the document
-            // it was built from, so the index over it still holds.
+            // One walk per structural change; a selection-only transaction leaves the document, so
+            // the index still holds.
             const scan = tr.docChanged ? scanDoc(next.doc) : undefined;
             if (scan)
                 index = lineIndexOf(scan);
-            // 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).
+            // Commit a content edit or an anchor mutation; an anchor edit is zero-width
+            // (`docChanged` false), so the `anchorKey` meta routes it.
             if (!held && (tr.docChanged || tr.getMeta(anchorKey))) {
                 // (d) the change signal, only for what actually landed.
                 const newRt = scan ? scanContent(scan) : pmToContent(next.doc);
                 if (commitEdit(oldRt, newRt))
                     opts.onChange?.(addr);
             }
-            // The caret, for both structural and selection-only changes: a host
-            // following the caret wants an arrow key, and a host recompiling wants
-            // `onChange`. Reported after the commit, so the edit has landed by the
-            // time the caret names where it is.
+            // The caret, for structural and selection-only changes, reported after the commit.
             opts.onCaretMove?.(addr, pmToUsv(index, next.selection.head));
         },
         handleDOMEvents: {
@@ -258,8 +225,10 @@ export function createField(opts) {
             }
         }
     });
-    /** The state, and the index over the document it was built from: the seed reads one
-     *  and every caller wants the same one, and `buildLineIndex` is a whole walk. */
+    /**
+     * The state, and the index over the document it was built from (`buildLineIndex` is a whole
+     * walk).
+     */
     function buildState(rt) {
         if (held) {
             const pmDoc = decode(rt, blockSchema);
@@ -293,25 +262,22 @@ export function createField(opts) {
         });
         return { state: built, index: seedIndex };
     }
-    // (b)+(c): lower the edit to ops and commit, or `overwrite` a field not yet at
-    // content rest. Keep the optimistic PM on throw.
-    // Returns whether anything landed: the caller's change signal, which must not
-    // be a property of which branch the commit took.
+    // (b)+(c): lower the edit to ops and commit, or `overwrite` a field not yet at content rest.
+    // Keeps the optimistic PM on throw. Returns whether anything landed, independent of which
+    // branch ran.
     function commitEdit(oldRt, newRt) {
         if (opts.emptyUnsets && heldAnchors().length === 0 && isEmptyContent(newRt))
             return commitUnset();
         if (plaintext)
             return commitPlain(newRt.text);
-        // The text splice, computed once per keystroke: the gate below, both overwrite
-        // fallbacks, and `lower` all read this one `edit`. The projection is the
-        // caller's, off the same walk that rebuilt the index.
+        // The text splice, computed once per keystroke and shared by the gate, both overwrite
+        // fallbacks and `lower`.
         const edit = contentEdit(oldRt, newRt);
         try {
-            // A field not yet at content rest is the only edit that overwrites by choice:
-            // `applyChange` throws on an absent declared field (verified), and neither an
-            // absent field nor an authored string has anchors to lose (`opsCommittable`).
-            // Every structural edit lowers, island creation included: the island channel
-            // places a slot the `delta` may not carry.
+            // Only a field not yet at content rest overwrites by choice: `applyChange` throws on an
+            // absent declared field, and neither it nor an authored string has anchors to lose
+            // (`opsCommittable`). Every structural edit lowers; the island channel places a slot
+            // the `delta` may not carry.
             if (!opsCommittable(doc, addr)) {
                 doc.overwrite(addr, edit.newRt); // brings the field to content rest
             }
@@ -324,10 +290,8 @@ export function createField(opts) {
             return true;
         }
         catch (e) {
-            // 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
+            // Bound the damage: after an op path the gates missed, the reconciler re-diffs from
+            // stale content and every later edit would re-throw. Install the full projection
             // (correct store, pays this field's anchors).
             reportError(opts.onError, {
                 code: 'commit-fallback',
@@ -353,14 +317,10 @@ export function createField(opts) {
         }
     }
     /**
-     * A `text` leaf's commit: its whole text through the typed writer, which rests the
-     * field as that literal string (CODEC §Inline mode). A content object is the
-     * other rest form, and `toMarkdown` emits one as markdown: a break spelled as a
-     * backslash, a `*` and a trailing space escaped, a blank line doubled, so the value
-     * reads back changed. The leaf carries no anchors, so the op path has none to keep.
-     *
-     * A refusal lands nothing and has no fallback, the other rest form being the
-     * corruption; the next edit writes the whole text again.
+     * A `text` leaf's commit: its whole text through the typed writer, resting the field as that
+     * literal string (CODEC §Inline mode). The content-object rest form would emit markdown
+     * (escaped `*`, backslash breaks) and read back changed. A refusal lands nothing and has no
+     * fallback; the next edit writes the whole text again.
      */
     function commitPlain(text) {
         try {
@@ -409,17 +369,12 @@ export function createField(opts) {
         el: container,
         setCaret(pos) {
             const pm = usvToPM(index, pos);
-            // `Selection.near`, not `TextSelection.create`: the mapped position can
-            // be non-inline (before an island/rule block, or doc-level in an empty
-            // nested textblock), where a raw TextSelection is invalid.
+            // `Selection.near`: the mapped position can be non-inline, where a raw TextSelection is
+            // invalid.
             const sel = Selection.near(view.state.doc.resolve(pm));
-            // Focus first, then the caret: the order a click's own pair arrives in, and the
-            // one a consumer that ends its caret follow on the arrival needs — the other
-            // way round, the arrival ends the follow this call just started.
-            //
-            // Flagged, because PM focuses with `preventScroll` and a landing is a caret
-            // move like any other: unflagged, the caret an arrow key would have revealed
-            // is left off screen by the click that placed it.
+            // Focus first, then the caret, the order a click arrives in: the other way round the
+            // arrival ends the follow this call just started. Flagged, since PM focuses with
+            // `preventScroll` and an unflagged landing leaves the caret off screen.
             view.focus();
             view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
         },
@@ -463,9 +418,8 @@ export function createField(opts) {
         },
         focus() {
             view.focus();
-            // The placement rung's reveal: no caret to flag a transaction with, so the
-            // trip is the element's, `nearest` and no clearance — the one the control
-            // lane's own focus takes, for the landing that means the same thing there.
+            // The placement rung's reveal: no caret to flag a transaction with, so the trip is the
+            // element's, `nearest`, no clearance.
             view.dom.scrollIntoView({ block: 'nearest' });
         },
         getContent() {
@@ -477,9 +431,8 @@ export function createField(opts) {
                 return;
             if (heldAnchors().some((a) => a.id === id))
                 return; // ids are unique + invariant (0.97 policy)
-            // An anchor commits through `applyChange`, so the field is brought to content
-            // rest first; else the commit's overwrite branch (value semantics) would drop
-            // the just-added anchor.
+            // An anchor commits through `applyChange`, so the field is brought to content rest
+            // first or the overwrite branch would drop it.
             if (!opsCommittable(doc, addr))
                 doc.overwrite(addr, reconciler.last);
             const pm = usvToPM(index, pos);
@@ -519,8 +472,7 @@ export function createField(opts) {
             view.destroy();
         }
     };
-    // The underlying views, exposed as available (undocumented) handles: the
-    // VisualEditor composes views, and tests drive edits through them.
+    // The underlying views, exposed for VisualEditor and tests.
     const handles = controller;
     handles.view = view;
     handles.nestedViews = () => [...nested];
@@ -535,24 +487,17 @@ export function createField(opts) {
     return controller;
 }
 /**
- * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
- * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, with the plugin that starts an
- * undo step at each block-moving edit (`undo.ts`), then any leaf-specific
- * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
- * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
- * the rest of the stack leaves, then the markdown-shorthand input rules and the
- * Backspace that takes one back, the field keymap over the base keymap, the URL paste
- * that links a selection (`link-paste.ts`), and last the ones that answer to a block
- * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
- * (`islands.ts`), the table paste (`table-paste.ts`), the markdown paste
- * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
- * paste joins its lines (`line-paste.ts`).
+ * The prose-leaf plugin stack (VISUAL_EDITOR §Surface), shared by {@link createField} and
+ * `ProseValue` so the two never fork the plugin ordering. History first with the step-splitting
+ * plugin (`undo.ts`), then `afterHistory` plugins (the addressed leaf's anchor plugin), {@link
+ * linebreakPlugin}, the markdown-shorthand input rules and their Backspace, the field keymap over
+ * the base keymap, the URL paste that links a selection (`link-paste.ts`), and last the block
+ * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste (`islands.ts`), table
+ * paste (`table-paste.ts`), markdown paste (`markdown-paste.ts`) and the task checkbox
+ * (`tasks.ts`). A one-line leaf's paste joins its lines (`line-paste.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
- * schema the shorthand rules build nothing (each is guarded on its mark type), the
- * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
- * its author typed without a second rule saying so.
+ * Mark-shaped plugins read the schema rather than a flag: over a mark-free schema the shorthand
+ * rules build nothing, the toggles bind no key and a pasted URL stays text.
  */
 export function proseLeafPlugins(schema, opts) {
     const list = [
@@ -570,8 +515,7 @@ export function proseLeafPlugins(schema, opts) {
     list.push(keymap(baseKeymap));
     if (schema.marks.link)
         list.push(linkPastePlugin(schema.marks.link));
-    // Each answers to something only the block schema holds: any other leaf is
-    // textblocks alone, with no island and no gap to put a cursor in.
+    // Each answers to something only the block schema holds.
     if (isBlockSchema(schema))
         list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), wordPastePlugin(), listPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
@@ -583,10 +527,8 @@ export function proseLeafPlugins(schema, opts) {
     return list;
 }
 /**
- * A plain leaf's clipboard text is literal, one line per `\n` both ways. Upstream's
- * defaults read pasted text as blocks split on any run of newlines, which drops a
- * blank line the value holds as content, and write a copy's blocks joined by a blank
- * line and its breaks as nothing.
+ * A plain leaf's clipboard text is literal, one line per `\n` both ways; upstream's defaults split
+ * pasted text on any run of newlines and write a copy's blocks joined by a blank line.
  */
 function plainClipboardPlugin() {
     const { paragraph } = plainSchema.nodes;
@@ -600,18 +542,11 @@ function plainClipboardPlugin() {
     });
 }
 /**
- * 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 the empty paragraph after it, or a new one where there is
- * none; an inline one the caret after the image in the same line: one rule, both node
- * types. Only a paragraph is reused, since an empty heading or fence would set the
- * text in a shape the key never asked for.
- *
- * PM routes text input over a non-`TextSelection` through `handleTextInput` before
- * falling back to replacing the selection, so this one prop is the whole of it.
- * Paste keeps replacing: a paste is deliberate, and it is the gesture that swaps one
- * island for another.
+ * A printable key over a selected atom writes past it: a selection is the subject of the next
+ * command, not armed for replacement. A block island takes the empty paragraph after it, or a new
+ * one; an inline one the caret after the image. Only a paragraph is reused. PM routes text input
+ * over a non-`TextSelection` through `handleTextInput`, so this one prop is the whole of it. Paste
+ * keeps replacing, as the gesture that swaps one island for another.
  */
 function pastAtomPlugin() {
     return new Plugin({
@@ -641,17 +576,11 @@ function pastAtomPlugin() {
     });
 }
 /**
- * The empty leaf's ghost. A node decoration stamps the sole empty textblock with a
- * class and the ghost text, which `prose.css` draws from the attribute: so the text
- * never enters the document, the caret path, or a `pmToContent` export, and it
- * vanishes the instant the leaf holds any content (the emptiness test fails).
- *
- * Under `placeholderUntilEdit` it is stamped only until the state's first edit, after
- * which the leaf has been answered. An inline leaf's ghost keeps to the one line the
- * leaf is (`qm-prose-placeholder-line`).
- *
- * The text is read per decoration pass rather than closed over, so moving the ghost is
- * a re-render and never a document edit.
+ * The empty leaf's ghost: a node decoration stamps the sole empty textblock with a class and the
+ * ghost text, which `prose.css` draws from the attribute, so the text never enters the document or
+ * a `pmToContent` export. Under `placeholderUntilEdit` it is stamped only until the state's first
+ * edit. An inline leaf's ghost keeps to one line (`qm-prose-placeholder-line`). The text is read
+ * per decoration pass, so moving the ghost is a re-render.
  */
 function ghostPlugin(opts) {
     const key = new PluginKey('qm-ghost');
@@ -684,15 +613,12 @@ function ghostPlugin(opts) {
     });
 }
 /**
- * The field's keymap: history, mark toggles, and the body's structural keys; Enter
- * suppressed inline. The toggles are bound per mark type the schema declares, so a
- * `text` leaf leaves Mod-b/i/u to the browser.
+ * The field's keymap: history, mark toggles (bound per mark type the schema declares), and the
+ * body's structural keys; Enter suppressed inline.
  *
- * Tab forks on the leaf's role, not on the caret's position. A one-line or `text`
- * 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.
+ * Tab forks on the leaf's role: a one-line or `text` leaf is a form field, Tab unbound so field
+ * navigation is open for a shell keymap (VISUAL_EDITOR §Settled and open); a block-schema body
+ * takes Tab structurally, a chain each nested surface prepends to (`keymap.ts`).
  */
 function editorKeymap(schema, inline, slash) {
     const map = {
@@ -706,11 +632,13 @@ function editorKeymap(schema, inline, slash) {
         map['Mod-i'] = toggleMark(schema.marks.em);
     if (schema.marks.underline)
         map['Mod-u'] = toggleMark(schema.marks.underline);
+    if (schema.marks.strike)
+        map['Mod-Shift-x'] = toggleMark(schema.marks.strike);
+    if (schema.marks.code)
+        map['Mod-e'] = toggleMark(schema.marks.code);
     if (inline) {
-        // One textblock only: swallow Enter so no second block is attempted. One *line*
-        // only too (`Content::is_inline`), so Shift-Enter goes with it: the schema
-        // declares no break node, and a declined key is the browser's, whose native
-        // `<br>` is the one thing that could put a second line in a field that holds one.
+        // One textblock only: swallow Enter, and Shift-Enter with it (the schema declares no break
+        // node; a declined key is the browser's native `<br>`).
         map['Enter'] = () => true;
         map['Shift-Enter'] = () => true;
     }

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

@@ -7,64 +7,56 @@ export declare const ISLAND_SLOT = "\uFFFC";
 export declare function isBlockIsland(type: ContentIsland['type']): boolean;
 /** Whether a leaf edits an island of `type`; one holding any other is held (`fitsLeaf`). */
 export declare function isEditedIsland(type: ContentIsland['type']): boolean;
-/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom. */
 export declare const islandBlockSpec: NodeSpec;
-/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a
- *  `para` line. */
+/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a `para` line. */
 export declare const islandInlineSpec: NodeSpec;
-/** A PM island node's attributes: the content entry, spelled the way a node spec
- *  spells it (`islandType`, because `type` on a PM node is the node type). `islandType`
- *  reads its set off the entry rather than restating it (DOCUMENT_MODEL §Stability
- *  seams). */
+/**
+ * A PM island node's attributes: the content entry, with `islandType` because `type` on a PM node
+ * is the node type; its set comes off the entry (DOCUMENT_MODEL §Stability seams).
+ */
 export interface IslandNodeAttrs {
     id: string;
     islandType: ContentIsland['type'];
     props: unknown;
 }
-/** Build a content island entry from a PM island node's attrs (block or inline). The
- *  cast pairs a closed `type` with a `props` that crossed the DOM as opaque JSON. The
- *  store is lenient about a table's shape — it fills what it can and keeps the rest —
- *  so a payload the arm does not hold is stored rather than refused, and `undefined` at
- *  its reader is what the surface draws the placeholder for (§`tablePropsOfNode`). */
+/**
+ * Build a content island entry from a PM island node's attrs. The cast pairs a closed `type` with a
+ * `props` that crossed the DOM as opaque JSON. The store is lenient about a table's shape, so a
+ * payload the arm does not hold is stored, and `undefined` at its reader draws the placeholder
+ * (§`tablePropsOfNode`).
+ */
 export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsland;
-/** A node's `TableProps`, or `undefined` for any other island and for a payload of the
- *  wrong shape: the boundary's own guard over the entry the node carries, so a `props`
- *  that crossed the DOM is read once here rather than at each reader. The type says
- *  which reader, the shape says whether it can read; every caller draws the placeholder
- *  for `undefined` (`table-view.ts` §`render`). */
+/**
+ * A node's `TableProps`, or `undefined` for any other island and for a payload of the wrong shape:
+ * the boundary's guard, so a `props` that crossed the DOM is read once here. Every caller draws the
+ * placeholder for `undefined` (`table-view.ts` §`render`).
+ */
 export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
 /**
- * A minter over one document: the positional `isl-{n}` sequence continued past the
- * highest id the field already holds, handing out consecutive ids, so a caller placing
- * several islands at once keeps one minter for the lot. A minted id is this tier's to
- * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and never a
- * re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the highest id the
+ * field holds, so a caller placing several islands keeps one minter. A minted id is part of the
+ * document's canonical bytes (CODEC §Islands): a counter over the projection in hand, never a UUID
+ * or clock reading, and never a re-numbering of existing ids.
  *
- * Reads the PM doc rather than the stored content because that is what the caller (an
- * insert command, a paste) holds and what the commit will project: an id minted against
- * a stale content could collide with one the same transaction places.
+ * Reads the PM doc rather than stored content because that is what the caller holds and the commit
+ * will project; a stale content could collide with an id the same transaction places.
  */
 export declare function islandMinter(doc: PMNode): () => string;
-/** The next island id for a field: one draw from {@link islandMinter}, which is what a
- *  command placing exactly one island wants. */
+/** The next island id for a field: one draw from {@link islandMinter}. */
 export declare function mintIslandId(doc: PMNode): string;
 /**
- * The paste's island pass: an id the field already holds is re-minted on the way in, and
- * an island arriving with none, a table read off foreign markup (`table-paste.ts`), takes
- * its first.
+ * The paste's island pass: an id the field already holds is re-minted on the way in, and an island
+ * arriving with none (a table read off foreign markup, `table-paste.ts`) takes its first.
  *
- * An id is an identity in the content and unique across the field, so two islands
- * wearing one is a projection the store has no shape for. A copy rather than a cut is
- * where that arrives, and a paste out of a second field is the other; a cut pasted back
- * collides with nothing and keeps the identity it had.
+ * Ids are unique across the field, so two islands wearing one is a projection the store has no
+ * shape for. That arrives by a copy or a paste from a second field; a cut pasted back collides with
+ * nothing and keeps its identity.
  *
- * The test is the document as it stands, which a drag moving a selection over an island
- * reads one too many: the original is still there when the slice is transformed and gone
- * when it lands, so that island arrives under a fresh id. A fresh id costs it nothing a
- * duplicate would cost the whole field.
+ * The test is the document as it stands, so a drag moving a selection over an island sees the
+ * original still there and mints a fresh id for the arrival, which costs nothing next to a
+ * duplicate.
  *
- * A plugin prop rather than a view option: the leaf mounts the codec's plugin stack, and
- * which nodes carry an identity is the codec's to know.
+ * A plugin prop rather than a view option: which nodes carry an identity is the codec's to know.
  */
 export declare function islandPastePlugin(): Plugin;