@quillmark/svelte 0.27.0 → 0.28.0

package/dist/core/codec/code.js

@@ -2,9 +2,11 @@ import { Selection, TextSelection } from 'prosemirror-state';
 import { newlineInCode } from 'prosemirror-commands';
 /** One indent level. */
 const UNIT = '  ';
-/** The enclosing code block's content start and text, or `null` when the selection
- * is not wholly inside one: a selection that escapes the block is a document-level
- * range, where the structural links keep their meaning. */
+/**
+ * The enclosing code block's content start and text, or `null` when the selection is not wholly
+ * inside one: a selection that escapes is a document-level range, where the structural links keep
+ * their meaning.
+ */
 function codeBlockAt(state) {
     const { $from, $to } = state.selection;
     if (!$from.parent.type.spec.code)
@@ -14,11 +16,8 @@ function codeBlockAt(state) {
     return { start: $from.start(), text: $from.parent.textContent };
 }
 /**
- * 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 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).
+ * Start offsets of the lines the range `[f, t)` covers. A line whose start is `t` is excluded on a
+ * non-empty range, so dragging to the next line's start does not indent one line too many.
  */
 function coveredLineStarts(text, f, t) {
     const last = t > f ? t - 1 : t;
@@ -31,9 +30,10 @@ function coveredLineStarts(text, f, t) {
     }
     return starts;
 }
-/** Width of the indent one outdent removes at line offset `s`: a leading tab, else
- * up to one unit of leading spaces (both forms, whatever Tab inserts). `0` when the
- * line carries no indent. */
+/**
+ * Width of the indent one outdent removes at line offset `s`: a leading tab, else up to one unit of
+ * leading spaces; `0` if none.
+ */
 function outdentWidth(text, s) {
     if (text[s] === '\t')
         return 1;
@@ -43,9 +43,8 @@ function outdentWidth(text, s) {
     return n;
 }
 /**
- * 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
- * types, the way any other key does.
+ * 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, as any key types.
  */
 const indentInCode = (state, dispatch) => {
     const block = codeBlockAt(state);
@@ -73,11 +72,9 @@ const indentInCode = (state, dispatch) => {
     return true;
 };
 /**
- * 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 falls through to the
- * list link: inside a `list_item > code_block` it lifts the item out
- * (`tests/codec/code-keys.test.ts`), and outside a list the body holds it (`keymap.ts`).
+ * Shift-Tab in a code block: remove one indent level from every covered line. Declines when none
+ * carries an indent, so the key falls through to the list link (lifting a `list_item > code_block`
+ * out of the item; `tests/codec/code-keys.test.ts`) or the body (`keymap.ts`).
  */
 const outdentInCode = (state, dispatch) => {
     const block = codeBlockAt(state);
@@ -99,10 +96,9 @@ const outdentInCode = (state, dispatch) => {
     return true;
 };
 /**
- * The textblock the caret's own block stands directly against on `side`: its sibling
- * under one parent, which is the only neighbour a press joins the text of. `null` at a
- * container's edge, where the base keymap moves the whole block in or out rather than
- * joining anything, and so changes nothing here.
+ * The textblock the caret's block stands directly against on `side`: its sibling under one parent,
+ * the only neighbour a press joins text with. `null` at a container's edge, where the base keymap
+ * moves the whole block instead.
  */
 function blockAgainst(state, side) {
     const { $from, empty } = state.selection;
@@ -117,18 +113,15 @@ function blockAgainst(state, side) {
     return { node, pos: side < 0 ? $edge.pos - node.nodeSize : $edge.pos };
 }
 /**
- * Backspace or Delete at a fence's edge, from either side, edits only the block the caret
- * is in.
+ * Backspace or Delete at a fence's edge, from either side, edits only the block the caret is in.
  *
- * Inside the fence, a press at its head or its end retypes it to a paragraph and joins
- * nothing: `toCodeBlock`'s inverse in its place (`blocks.ts`), taking no text with it,
- * since `linebreakReplacement` carries the fence's newlines across as breaks
- * (`schema.ts`). The press after that is an ordinary join between two prose blocks.
+ * Inside the fence, a press at its head or end retypes it to a paragraph and joins nothing
+ * (`toCodeBlock`'s inverse, `blocks.ts`); `linebreakReplacement` carries the newlines across as
+ * breaks (`schema.ts`). The press after is an ordinary prose join.
  *
- * From the prose block against it, the caret steps into the fence, to the end it faces,
- * and the fence is left as it is: a join would retype one side's whole text as the
- * other's kind, and a retype from outside edits a block the caret is not in. An empty
- * line under a fence goes with the step, its Backspace having nothing of its own to edit.
+ * From the prose block against it, the caret steps into the fence at the end it faces and the fence
+ * is left as it is: a join would retype one side's text as the other's kind. An empty line under a
+ * fence goes with the step.
  *
  * Declines where both sides are code and where neither is: those joins retype nothing.
  */
@@ -155,9 +148,10 @@ function atProseEdge(side) {
         return true;
     };
 }
-/** ↓ on the last line of a fence nothing follows → a paragraph after it, the caret
- *  there: no block stands below to arrow to, and a gap cursor will not sit beside a
- *  fence. */
+/**
+ * ↓ on the last line of a fence nothing follows → a paragraph after it, the caret there: a gap
+ * cursor will not sit beside a fence.
+ */
 const belowFinalFence = (state, dispatch) => {
     const paragraph = state.schema.nodes.paragraph;
     const { $from, empty } = state.selection;
@@ -177,17 +171,14 @@ const belowFinalFence = (state, dispatch) => {
     return true;
 };
 /**
- * The `code_block` link of the body's key chains: `{}` for the one-line and plain
- * schemas, which declare no code node.
+ * The `code_block` link of the body's key chains: `{}` for the one-line and plain schemas, which
+ * declare no code node.
  *
- * `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. `Shift-Enter` is
- * the same command because it is the same edit: the line break the key means
- * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
- * Every command here declines away from a code block — inside one for the keys about
- * its text and its last line, against one for the two about its edge — so the list
- * links keep the keys elsewhere.
+ * `Enter` is upstream's `newlineInCode`, load-bearing: inside a `list_item > code_block` the list
+ * link's `splitListItem` would otherwise split the item in two. `Shift-Enter` is the same command:
+ * the line break the key means elsewhere (`breaks.ts`) is, inside a fence, the newline Enter takes.
+ * Every command here declines away from a code block (inside it for the text and last-line keys,
+ * against it for the two edge keys), leaving the list links the keys elsewhere.
  */
 export function codeKeymap(schema) {
     if (!schema.nodes.code_block)

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

@@ -5,35 +5,31 @@ export declare function codePoints(s: string): string[];
 /** USV length of `s` (code points, not UTF-16 units). */
 export declare function usvLength(s: string): number;
 /**
- * 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
- * same content would drift from `decode`; this cannot.
- *
- * `DOMSerializer.fromSchema` memoizes on the schema, so repeat calls build no
- * serializer.
+ * A `Content` as read-only DOM: decode under `schema`, then the nodes' own `toDOM`, for chrome that
+ * must show content in the mark vocabulary a leaf edits it in (the tips card) without a second
+ * renderer to drift from `decode`. `DOMSerializer.fromSchema` memoizes on the schema.
  */
 export declare function renderContent(rt: Content, schema: Schema): Node;
 /** Decode a `Content` to a PM document under `schema`. */
 export declare function decode(rt: Content, schema: Schema): PMNode;
-/** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
- *  upstream ignores and the inline decode drops. Marks are the schema's own business
- *  (`plaintextSchema` declares none). */
+/**
+ * Whether `rt` decodes under an inline schema with nothing but whitespace dropped: upstream's
+ * one-line rule, or one plain line and the empty one a trailing `\n` opens (the one a YAML `|`
+ * scalar keeps in a `text` value). Marks are the schema's business.
+ */
 export declare function fitsInline(rt: Content): boolean;
-/** Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the
- *  next commit heals (CODEC §Inline mode): upstream's `isPlain`, asked of the content
- *  with them set aside. */
+/**
+ * Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the next commit
+ * heals (CODEC §Inline mode): upstream's `isPlain` with marks set aside.
+ */
 export declare function fitsPlain(rt: Content): boolean;
-/** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
- *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but a construct read and not edited — an element,
- *  a definition list ({@link editable}), a footnote or an equation (`isEditedIsland`) —
- *  and an island where the leaf mounts no island view (`islands`), which draws as its
- *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
- *  reads. */
+/**
+ * Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed and {@link
+ * fitsPlain} plain, past which the decode drops what the first commit would store. On the block
+ * schema, anything but a construct read and not edited (`isEditedIsland`) and an island where the
+ * leaf mounts no island view (`islands`), which draws as a placeholder atom a keystroke deletes
+ * unseen.
+ */
 export declare function fitsLeaf(rt: Content, leaf: {
     inline: boolean;
     plaintext: boolean;

package/dist/core/codec/decode.js

@@ -1,12 +1,9 @@
-// Decode: content → PM, a pure function (CODEC §Decode). Fold the flat lines into
-// the tree: group a `continues` run into one block (para hard breaks → `hard_break`
-// nodes; a code fence's lines → one `code_block`), nest by shared `containers`
-// 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 (block where a block
-// island's slot stands alone on its line, inline otherwise). 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.
+// Decode: content → PM, a pure function (CODEC §Decode). Fold the flat lines into the tree: group a
+// `continues` run into one block (para hard breaks → `hard_break`; a fence's lines → one
+// `code_block`), nest by shared `containers` prefix, select the block node by `kind`, apply marks
+// over their `[start,end)` USV ranges, and lower island slots to leaf nodes. Anchors are
+// decorations (field.ts). Positions are USV; `Array.from` iterates by code point so an astral char
+// is one unit.
 import { DOMSerializer } from 'prosemirror-model';
 import { ISLAND_SLOT, isBlockIsland, isEditedIsland } from './islands.js';
 import { descriptorOf, markKey, pmMarkFromContent } from './marks.js';
@@ -24,14 +21,9 @@ export function usvLength(s) {
     return n;
 }
 /**
- * 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
- * same content would drift from `decode`; this cannot.
- *
- * `DOMSerializer.fromSchema` memoizes on the schema, so repeat calls build no
- * serializer.
+ * A `Content` as read-only DOM: decode under `schema`, then the nodes' own `toDOM`, for chrome that
+ * must show content in the mark vocabulary a leaf edits it in (the tips card) without a second
+ * renderer to drift from `decode`. `DOMSerializer.fromSchema` memoizes on the schema.
  */
 export function renderContent(rt, schema) {
     return DOMSerializer.fromSchema(schema).serializeFragment(decode(rt, schema).content);
@@ -46,14 +38,12 @@ export function decode(rt, schema) {
         starts.push(acc);
         acc += usvLength(lineTexts[i]) + 1; // +1 for the `\n` boundary
     }
-    // A mark-free schema (`plaintextSchema`) has nothing to apply them with, and a
-    // `text` field that acquired one anyway — an older build's popover, a hand-written
-    // document — is exactly the content that must open and then heal on the next
-    // commit, not throw here.
+    // A mark-free schema has nothing to apply marks with, and a `text` field that acquired one
+    // anyway (a hand-written document) must open and heal on the next commit, not throw.
     const marks = hasMarks(schema) ? rt.marks.filter((m) => m.type !== 'anchor') : [];
     const cursor = { i: 0, rt };
     if (isInlineSchema(schema)) {
-        return decodeInline(rt, schema, lineTexts, starts, marks, cursor);
+        return decodeInline(schema, lineTexts, starts, marks, cursor);
     }
     if (!isBlockSchema(schema)) {
         return decodePlain(rt, schema, lineTexts, starts, marks, cursor);
@@ -73,11 +63,11 @@ export function decode(rt, schema) {
     const blocks = groupBlocks(schema, leaves, 0, marks, cursor);
     return schema.nodes.doc.create(null, blocks.length ? blocks : schema.nodes.paragraph.create());
 }
-/** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
- *  upstream ignores and the inline decode drops. Marks are the schema's own business
- *  (`plaintextSchema` declares none). */
+/**
+ * Whether `rt` decodes under an inline schema with nothing but whitespace dropped: upstream's
+ * one-line rule, or one plain line and the empty one a trailing `\n` opens (the one a YAML `|`
+ * scalar keeps in a `text` value). Marks are the schema's business.
+ */
 export function fitsInline(rt) {
     if (core().isInline(rt))
         return true;
@@ -88,19 +78,20 @@ export function fitsInline(rt) {
         !rt.lines[1].continues &&
         rt.text.endsWith('\n'));
 }
-/** Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the
- *  next commit heals (CODEC §Inline mode): upstream's `isPlain`, asked of the content
- *  with them set aside. */
+/**
+ * Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the next commit
+ * heals (CODEC §Inline mode): upstream's `isPlain` with marks set aside.
+ */
 export function fitsPlain(rt) {
     return core().isPlain({ ...rt, marks: [] });
 }
-/** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
- *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but a construct read and not edited — an element,
- *  a definition list ({@link editable}), a footnote or an equation (`isEditedIsland`) —
- *  and an island where the leaf mounts no island view (`islands`), which draws as its
- *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
- *  reads. */
+/**
+ * Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed and {@link
+ * fitsPlain} plain, past which the decode drops what the first commit would store. On the block
+ * schema, anything but a construct read and not edited (`isEditedIsland`) and an island where the
+ * leaf mounts no island view (`islands`), which draws as a placeholder atom a keystroke deletes
+ * unseen.
+ */
 export function fitsLeaf(rt, leaf) {
     if (leaf.inline)
         return fitsInline(rt);
@@ -108,22 +99,13 @@ export function fitsLeaf(rt, leaf) {
         return fitsPlain(rt);
     if (!leaf.islands && rt.islands.length)
         return false;
-    return rt.islands.every((isl) => isEditedIsland(isl.type)) && rt.lines.every(editable);
-}
-/** Whether the block schema edits `line`'s kind and every container on it: a term draws
- *  as a paragraph and an element and a description as the blocks they wrap, so the first
- *  commit would drop each. */
-function editable(line) {
-    if (line.kind === 'term')
-        return false;
-    return line.containers.every((c) => c.container === 'quote' || c.container === 'list_item');
+    return rt.islands.every((isl) => isEditedIsland(isl.type));
 }
 /** Inline decode: one paragraph, containers and islands stripped. */
-function decodeInline(rt, schema, lineTexts, starts, marks, cursor) {
-    // An inline field is single-line; join any stray lines with a space (no
-    // hard_break node exists in this schema). The empty line a trailing `\n` opens is
-    // dropped rather than joined, so a first edit stores no space nobody typed. Islands
-    // are not representable inline: the slot char is dropped and its entry skipped.
+function decodeInline(schema, lineTexts, starts, marks, cursor) {
+    // An inline field is single-line: stray lines join with a space. The empty line a trailing `\n`
+    // opens is dropped, so a first edit stores no space nobody typed. Islands are not representable
+    // inline: the slot char is dropped and its entry skipped.
     const inline = [];
     const last = lineTexts.length - 1;
     for (let i = 0; i < lineTexts.length; i++) {
@@ -136,9 +118,11 @@ function decodeInline(rt, schema, lineTexts, starts, marks, cursor) {
     const para = schema.nodes.paragraph.create(null, inline);
     return schema.nodes.doc.create(null, para);
 }
-/** Plain decode: a `continues` line is a `hard_break` in the paragraph above and every
- *  other line opens one. A line's kind and containers and every island have no node
- *  here and are dropped, so a content {@link fitsPlain} refuses opens flattened. */
+/**
+ * Plain decode: a `continues` line is a `hard_break` in the paragraph above and every other line
+ * opens one. Line kinds, containers and islands are dropped, so content {@link fitsPlain} refuses
+ * opens flattened.
+ */
 function decodePlain(rt, schema, lineTexts, starts, marks, cursor) {
     const paras = [];
     for (let i = 0; i < rt.lines.length; i++) {
@@ -198,25 +182,9 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             i = j;
             continue;
         }
-        if (here.container === 'element' || here.container === 'description') {
-            // No node holds an element or a description, and a leaf holding one is held
-            // (`fitsLeaf`), so what it wraps draws in place, read-only.
-            const key = containerKey(here);
-            let j = i + 1;
-            while (j < leaves.length) {
-                const c = atDepth(leaves[j], depth);
-                if (!c || containerKey(c) !== key)
-                    break;
-                j++;
-            }
-            out.push(...groupBlocks(schema, leaves.slice(i, j), depth + 1, marks, cursor));
-            i = j;
-            continue;
-        }
-        // The quote, and the whole of what is left: `satisfies` is the exhaustiveness
-        // check, so a container added upstream is a compile error here rather than a
-        // blockquote it is not. A wrapper over the run of leaves carrying the identical
-        // container here, identity by `containerKey`.
+        // The quote, and the whole of what is left: `satisfies` makes a container added upstream a
+        // compile error. A wrapper over the run of leaves carrying the identical container
+        // (`containerKey`).
         here.container;
         const key = containerKey(here);
         let j = i + 1;
@@ -235,8 +203,10 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
 function atDepth(leaf, depth) {
     return leaf.containers[depth];
 }
-/** The `ordinal` of a leaf's `list_item` at `depth`: only called inside a run the
- * discriminant has already established, so a miss is unreachable. */
+/**
+ * The `ordinal` of a leaf's `list_item` at `depth`, only called inside a run the discriminant
+ * established.
+ */
 function ordinalAt(leaf, depth) {
     const c = atDepth(leaf, depth);
     return c?.container === 'list_item' ? c.attrs.ordinal : -1;
@@ -247,22 +217,23 @@ function checkedAt(leaf, depth) {
     const c = atDepth(leaf, depth);
     return c?.container === 'list_item' ? (c.attrs.checked ?? null) : null;
 }
-/** A container's `instance`, absent meaning the zero a canonical read omits. It is what
- * tells one container from an adjacent sibling of identical shape, which contiguity
- * alone reads as one, so absent and `0` have to answer alike. */
+/**
+ * A container's `instance`, absent meaning the zero a canonical read omits. It tells one container
+ * from an adjacent sibling of identical shape, so absent and `0` answer alike.
+ */
 function instanceOf(c) {
     return c.instance ?? 0;
 }
-/** Identity of a container for run gathering: its name, its `instance` and an element's
- * attributes, NUL-joined as `markKey` joins a mark's. `list_item` carries its own run
- * rule, so the rest are what key here. */
+/** Identity of a container for run gathering: its name and its `instance`, NUL-joined
+ * as `markKey` joins a mark's. `list_item` carries its own run rule, so the rest are what
+ * key here. */
 function containerKey(c) {
-    const attrs = c.container === 'element' ? JSON.stringify(c.attrs) : '';
-    return `${c.container}\u0000${instanceOf(c)}\u0000${attrs}`;
+    return `${c.container}\u0000${instanceOf(c)}`;
 }
-/** A single leaf block node from its segments. Exhaustive over the closed line
- *  vocabulary, so a kind added upstream is a compile error rather than a silent
- *  flattening to `para` that the next commit would store. */
+/**
+ * A single leaf block node from its segments, exhaustive over the closed line vocabulary so a kind
+ * added upstream is a compile error.
+ */
 function makeLeaf(schema, leaf, marks, cursor) {
     const line = leaf.line;
     switch (line.kind) {
@@ -275,15 +246,12 @@ function makeLeaf(schema, leaf, marks, cursor) {
             return schema.nodes.code_block.create({ lang: line.attrs?.lang ?? null }, content);
         }
         case 'para':
-        case 'term':
         case 'heading': {
             if (line.kind !== 'heading' && blockIslandLine(leaf, cursor))
                 return schema.nodes.island_block.create(islandAttrs(cursor));
-            // Inline content, the segment boundary a `hard_break` in a paragraph and a space
-            // in a heading, which takes none (`schema.ts` §`takesLineBreak`). A stored heading
-            // carries no continuation — the store clears one after a block of a single line —
-            // so the space is what keeps a hand-built content decodable. A term draws as a
-            // paragraph, read-only (`fitsLeaf`).
+            // Inline content: the segment boundary is a `hard_break` in a paragraph and a space in
+            // a heading, which takes none (`schema.ts` §`takesLineBreak`). A stored heading carries
+            // no continuation, so the space keeps hand-built content decodable.
             const type = line.kind === 'heading' ? schema.nodes.heading : schema.nodes.paragraph;
             const inline = [];
             leaf.segments.forEach((seg, idx) => {
@@ -301,29 +269,29 @@ function makeLeaf(schema, leaf, marks, cursor) {
         }
     }
 }
-/** Whether a `para` leaf is one block island: a single line holding its slot alone,
- *  backed by an island whose markup is a block. The island is the one fact; the line
- *  carries no kind of its own for it. */
+/**
+ * Whether a `para` leaf is one block island: a single line holding its slot alone, backed by an
+ * island whose markup is a block.
+ */
 function blockIslandLine(leaf, cursor) {
     if (leaf.segments.length !== 1 || leaf.segments[0].text !== ISLAND_SLOT)
         return false;
     const isl = cursor.rt.islands[cursor.i];
     return isl != null && isBlockIsland(isl.type);
 }
-/** Consume the next island entry as PM node attrs (text-order matched to slots): the
- *  whole entry, which an island edit has to write back (`islands.ts`). `null` where a
- *  slot has no entry behind it, which is a malformed content: the slot draws nothing
- *  and its line an empty paragraph, so the decode stays total without minting a node
- *  whose `type` the vocabulary would refuse on the way back. */
+/**
+ * Consume the next island entry as PM node attrs (text-order matched to slots): the whole entry,
+ * which an island edit writes back (`islands.ts`). `null` where a slot has no entry (malformed
+ * content): the slot draws nothing, keeping the decode total.
+ */
 function islandAttrs(cursor) {
     const isl = cursor.rt.islands[cursor.i++];
     return isl ? { id: isl.id, islandType: isl.type, props: isl.props } : null;
 }
 /**
- * Inline nodes for one segment: split text into maximal runs of a constant mark
- * set, lower each `U+FFFC` to an inline island node. `stripIslands` drops slots
- * (inline-field mode). Offsets are USV; `pos = segStartUSV + k` indexes into the
- * global mark ranges.
+ * Inline nodes for one segment: split text into maximal runs of a constant mark set, lower each
+ * `U+FFFC` to an inline island node. `stripIslands` drops slots. `pos = segStartUSV + k` indexes
+ * into the global mark ranges.
  */
 function buildInline(schema, segText, segStartUSV, marks, cursor, stripIslands) {
     const cps = codePoints(segText);
@@ -336,9 +304,8 @@ function buildInline(schema, segText, segStartUSV, marks, cursor, stripIslands)
             out.push(schema.text(runText, runMarks));
         runText = '';
     };
-    // A mark set changes only where a mark starts or ends. `marks` is the field's whole
-    // list, so resolving one per code point costs the text against every mark in the
-    // document.
+    // A mark set changes only where a mark starts or ends; `marks` is the whole list, so resolving
+    // per code point would cost the text against every mark.
     const segEndUSV = segStartUSV + cps.length;
     const spanning = marks.filter((m) => m.start < segEndUSV && m.end > segStartUSV);
     const edges = new Set();
@@ -384,10 +351,8 @@ function buildInline(schema, segText, segStartUSV, marks, cursor, stripIslands)
 function markSetKey(active) {
     if (!active.length)
         return '';
-    // Per-mark keys via the shared descriptor + NUL-delimited `markKey`: the same
-    // pair the mark diff groups families by, so a run boundary and a mark family are
-    // one rule. The set is JSON-joined so no url/attrs content collides with a
-    // delimiter: a `link:a|strong` url stays distinct from `{link:a} + {strong}`.
+    // Per-mark keys via the shared descriptor + NUL-delimited `markKey`, the pair the mark diff
+    // groups by. JSON-joined so a `link:a|strong` url stays distinct from `{link:a} + {strong}`.
     return JSON.stringify(active.map((m) => markKey(descriptorOf(m))).sort());
 }
 /** The PM mark array for an active content mark set (anchors already excluded). */

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

@@ -25,13 +25,14 @@ export interface Scan {
     usvEnd: number;
 }
 /**
- * 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.
+ * Walk a PM document once, producing the content projection and the position-map runs; sharing the
+ * traversal means they cannot disagree.
  */
 export declare function scanDoc(doc: PMNode): Scan;
-/** The content projection a scan carries (drops the position runs): what a caller
- *  holding a `Scan` reads instead of walking the document a second time. */
+/**
+ * The content projection a scan carries, for a caller holding a `Scan` that would otherwise walk
+ * again.
+ */
 export declare function scanContent(s: Scan): Content;
 /** `pmToContent`: the pure inverse of decode (drops the position runs). */
 export declare function pmToContent(doc: PMNode): Content;
@@ -44,16 +45,11 @@ interface LowerOpts {
     }[];
 }
 /**
- * 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.
- *
- * The splice rides along because `diffText` allocates a code-point array per side
- * 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.
+ * One old→new content edit with the text splice it implies. Both sides are content, never a PM doc:
+ * a doc-taking overload would re-walk the tree per keystroke for a projection the caller holds. The
+ * splice rides along because `diffText` allocates a code-point array per side. `contentEdit` is its
+ * only constructor, which keeps a `delta` agreeing with the contents it was diffed from; `lower`
+ * moves a slot inside the splice to the island channel, so this `delta` is the raw splice.
  */
 export interface ContentEdit {
     readonly oldRt: Content;