@quillmark/svelte 0.26.2 → 0.28.0

package/dist/core/codec/prose.css

@@ -23,11 +23,12 @@
 	outline: var(--_qm-ring);
 }
 /* Upstream's `-32px` is measured against the UA's 40px list indent, which the list
-   rule below replaces with a rung. The offset moves with it, or a selected item's
-   outline hangs into the margin by the difference. */
+   rule below replaces. The offset is that indent, so a selected item's outline takes in
+   its marker and stands on the list's own edge rather than crossing a `10.` or hanging
+   into the margin. */
 li.ProseMirror-selectednode::after {
 	border: var(--_qm-ring);
-	left: calc(var(--_qm-space-4) * -1);
+	left: calc(-1 * (var(--_qm-marker-digits) + var(--_qm-nest)));
 }
 /* A node selection is drawn while its leaf holds the focus, as a text selection is: a
    ring left behind on a field the focus has moved off names a subject no key reaches. */
@@ -57,29 +58,17 @@ li.ProseMirror-selectednode::after {
 /* One rhythm between sibling blocks, in place of the UA's collapsed pair. Scoped by
    parent rather than by tag, which is what keeps it true as the schema grows: the
    containers below are every node whose children are blocks (`schema.ts`), whatever
-   kinds exist; a task item holds its blocks in a body past its checkbox (`tasks.ts`),
-   so the body is the container rather than the item. A list and an item are
-   containers like any other: an item stands off its neighbours as a paragraph does, a
-   list nested under an item stands off the item's text, and an item's unnumbered line
-   has the gap below it that the next item draws above, where a tight run would read it
-   as the head of the next item.
+   kinds exist. A list is the exception: the whole list is one block among its
+   siblings, so it stands off them by the gap and its insides are tight: items, an
+   item's unnumbered lines, a task item's body and a sub-list all sit flush, told
+   apart by marker and indent rather than by space.
 
    A line box is ~22px at the paper size and the body leading, so the rung is a
    little over half a line: enough that a break reads as a break, short of the full
    blank line that doubles the leading and makes a short document read as a list of
    fragments. */
 .ProseMirror > * + *,
-.ProseMirror
-	:is(
-		blockquote,
-		ul,
-		ol,
-		li:not([data-qm-checked]),
-		[data-qm-task-body],
-		[data-qm-unknown-container]
-	)
-	> *
-	+ * {
+.ProseMirror :is(blockquote, [data-qm-unknown-container]) > * + * {
 	margin-top: var(--_qm-space-3);
 }
 
@@ -203,7 +192,9 @@ li.ProseMirror-selectednode::after {
 }
 
 /* The UA's 40px list indent is the one box the reset above does not take (it is
-   padding, not margin), and it is a length nothing chose. A rung replaces it.
+   padding, not margin), and it is a length nothing chose. The indent is room for a
+   marker's two digits and the nesting step past them, so a marker, `10.` included,
+   hangs into its own list's indent and never past the leaf's edge.
 
    The markers are the UA's, reclaimed rather than inherited. `disc` and `decimal`
    are right and this restates neither: a host reset (Tailwind's preflight sets
@@ -217,7 +208,7 @@ li.ProseMirror-selectednode::after {
    that takes those ever turns up: the positive half states what it leaves to the
    UA, and what a reset takes is what has to be asked back. */
 .ProseMirror :is(ul, ol) {
-	padding-left: var(--_qm-space-4);
+	padding-left: calc(var(--_qm-marker-digits) + var(--_qm-nest));
 	list-style: revert;
 }
 
@@ -240,7 +231,7 @@ li.ProseMirror-selectednode::after {
 	width: var(--_qm-glyph-control);
 	height: var(--_qm-glyph-control);
 	border: var(--_qm-border-width) solid var(--_qm-border);
-	border-radius: calc(var(--_qm-radius-inner) / 2);
+	border-radius: var(--_qm-radius-inner);
 	background: var(--_qm-surface-well);
 	cursor: pointer;
 	transition:
@@ -277,10 +268,8 @@ li.ProseMirror-selectednode::after {
 /* Six levels, one weight, no size step. The quill reads no level at all, so a size
    ramp here would be the editor predicting a hierarchy the paper does not set; the
    level stays in the model, which is where the codec round-trips it. It is also all
-   the ramp could carry: this leaf renders at `--_qm-text-paper` and the next rung up
-   is `--_qm-text-title`, a chrome rung a heading inside a document has no business
-   reading. Six levels do not fit in the gap, and
-   minting five more is the drift the scale exists to prevent. */
+   the ramp could carry: this leaf renders at `--_qm-text-paper`, the top of the ramp,
+   and minting six more is the drift the scale exists to prevent. */
 .ProseMirror :is(h1, h2, h3, h4, h5, h6) {
 	font-size: inherit;
 	font-weight: var(--_qm-weight-strong);
@@ -413,7 +402,7 @@ li.ProseMirror-selectednode::after {
 .qm-table {
 	border-collapse: separate;
 	border-spacing: 0;
-	border: var(--_qm-border-width) solid var(--_qm-rule);
+	border: var(--_qm-border-width) solid var(--_qm-border);
 	border-radius: var(--_qm-radius);
 }
 /* One rule at one strength, the frame's and every line between cells, so the grid
@@ -421,19 +410,32 @@ li.ProseMirror-selectednode::after {
    `collapse`: a collapsed border cannot be rounded. */
 .qm-table-cell {
 	position: relative;
-	border-right: var(--_qm-border-width) solid var(--_qm-rule);
-	border-bottom: var(--_qm-border-width) solid var(--_qm-rule);
+	border-right: var(--_qm-border-width) solid var(--_qm-border);
+	border-bottom: var(--_qm-border-width) solid var(--_qm-border);
 	padding: var(--_qm-space) var(--_qm-space-2);
 	vertical-align: top;
 	font-weight: inherit;
 	text-align: inherit;
 }
-.qm-table tr > .qm-table-cell:last-child {
+.qm-table-cell[data-edge-end] {
 	border-right: none;
 }
-.qm-table tbody tr:last-child > .qm-table-cell {
+.qm-table-cell[data-edge-bottom] {
 	border-bottom: none;
 }
+/* The rails: a row of no height above the first and a column of no width before the
+   first, which the grips and border handles hang off rather than the first row's and
+   column's cells, a merged cell there standing over several lines. */
+.qm-table-rail-cell {
+	position: relative;
+	width: 0;
+	height: 0;
+	padding: 0;
+	border: none;
+}
+.qm-table-rail-col {
+	width: 0;
+}
 /* The header row is the one weight distinction the island draws: `header` is a
    separate field in the model rather than a flag on a row, so the surface says so.
    It takes a tone with it, the band rung, a step toward the ink at both poles. The
@@ -444,20 +446,17 @@ li.ProseMirror-selectednode::after {
 }
 /* The corner cells take the frame's corner, inside its stroke, so a header's band or a
    selection's wash keeps to the rounded edge rather than painting a square one over
-   it. The first row is the colgroup's next sibling's, whichever section holds it. */
-.qm-table > colgroup + * > tr:first-child > .qm-table-cell:first-child {
+   it. A merged cell takes each corner its span reaches. */
+.qm-table-cell[data-corners~='start-start'] {
 	border-start-start-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
 }
-.qm-table > colgroup + * > tr:first-child > .qm-table-cell:last-child {
+.qm-table-cell[data-corners~='start-end'] {
 	border-start-end-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
 }
-.qm-table
-	> :is(:last-child, thead:has(+ tbody:empty))
-	> tr:last-child
-	> .qm-table-cell:first-child {
+.qm-table-cell[data-corners~='end-start'] {
 	border-end-start-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
 }
-.qm-table > :is(:last-child, thead:has(+ tbody:empty)) > tr:last-child > .qm-table-cell:last-child {
+.qm-table-cell[data-corners~='end-end'] {
 	border-end-end-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
 }
 /* A cell holds a whole nested view. Its measure floor keeps an empty table from
@@ -659,10 +658,14 @@ li.ProseMirror-selectednode::after {
 /* The held column's alignment cluster, hung off its header cell and floating over the
    first row, the band's top edge being the grips'. Up only while its column is held and
    absent otherwise (`table-view.ts` §`alignCluster`), so the reveal is `hidden` rather
-   than the band's opacity. It floats over content it did not choose, so the edge and
-   `--_qm-lift` separate it and the raised rung joins them in dark (ARCHITECTURE
-   §Styling). The pressed toggle takes the selected grip's tint and accent: it names the
-   held column's alignment the way the grip names the held line. */
+   than the band's opacity. It is a row of glyphs floating over text, the format popover's
+   family (ARCHITECTURE §Styling), and takes that recipe: the popover's translucent
+   surface over a blur, the edge and `--_qm-lift` for its separation, and a scale-in on
+   arrival, stated from its starting style since the codec shows it by clearing
+   `hidden`. Its geometry is the popover's too, a row of toggles held one rung in from
+   a surface at the card's radius, so the two floating rows of glyphs are one height,
+   one shape and one material. The pressed toggle takes the selected grip's tint and
+   accent: it names the held column's alignment the way the grip names the held line. */
 .qm-table-align {
 	position: absolute;
 	z-index: 2;
@@ -671,10 +674,21 @@ li.ProseMirror-selectednode::after {
 	width: max-content;
 	margin-inline: auto;
 	display: flex;
+	gap: var(--_qm-space-half);
+	padding: var(--_qm-space);
 	border: var(--_qm-border-width) solid var(--_qm-border);
-	border-radius: var(--_qm-radius-inner);
-	background: var(--_qm-surface-raised);
+	border-radius: var(--_qm-radius);
+	background: var(--_qm-surface-popover);
+	backdrop-filter: blur(var(--_qm-blur));
+	-webkit-backdrop-filter: blur(var(--_qm-blur));
 	box-shadow: var(--_qm-lift);
+	transition:
+		opacity var(--_qm-duration-fast) var(--_qm-ease-reverse),
+		transform var(--_qm-duration-fast) var(--_qm-ease-reverse);
+	@starting-style {
+		opacity: 0;
+		transform: scale(0.94);
+	}
 }
 .qm-table-align[hidden] {
 	display: none;
@@ -684,6 +698,30 @@ li.ProseMirror-selectednode::after {
 .qm-table-align[data-header] {
 	margin-inline: auto 0;
 }
+/* The merge and split cluster hangs under the held block's first cell, flush with its
+   leading edge, its options worded. */
+.qm-table-align[data-cells] {
+	margin-inline: 0 auto;
+}
+.qm-table-cells-option {
+	display: flex;
+	align-items: center;
+	min-height: var(--_qm-tap-min);
+	padding: 0 var(--_qm-space-2);
+	border: none;
+	border-radius: var(--_qm-radius-inner);
+	background: none;
+	color: var(--_qm-ink);
+	font: inherit;
+	white-space: nowrap;
+	cursor: pointer;
+}
+.qm-table-cells-option:hover {
+	background: var(--_qm-surface-hover);
+}
+.qm-table-cells-option[hidden] {
+	display: none;
+}
 .qm-table-align-option {
 	display: flex;
 	align-items: center;

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

@@ -2,34 +2,28 @@ import { Schema } from 'prosemirror-model';
 import type { NodeType } from 'prosemirror-model';
 /** The full field schema: every block kind, container, mark, and island. */
 export declare const blockSchema: Schema<string, string>;
-/** The constrained inline schema: one paragraph, no block splitting, no
- *  containers, no islands, and the full mark set (a `richtext(inline)` field). */
+/**
+ * The constrained inline schema: one paragraph, no containers or islands, the full mark set (a
+ * `richtext(inline)` field).
+ */
 export declare const inlineSchema: Schema<string, string>;
 /**
- * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
- * value is literal text the boundary refuses to coerce back once it carries a mark.
- *
- * Declaring none is what makes that structural rather than a rule each path
- * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
- * a paste parses its marks away, and `decode` drops any a stray content arrives
- * carrying (CODEC §Inline mode).
+ * The inline schema with no mark types: a `plaintext(inline)` field, whose value is literal text
+ * the boundary refuses to coerce back once it carries a mark. Declaring none makes that structural:
+ * `toggleMark` has no type, the mark input rules build nothing, a paste parses marks away, and
+ * `decode` drops any a stray content carries (CODEC §Inline mode).
  */
 export declare const plaintextSchema: Schema<string, never>;
 /**
- * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a
- * `\n` in its `text`. Still one paragraph, so Enter has no block to split; a break is
- * Shift-Enter's (`breaks.ts`). Declaring the break routes `decode` through the plain
- * path, which folds a cell's `continues` lines into that one paragraph.
+ * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a `\n` in its
+ * `text`. Still one paragraph; a break is Shift-Enter's (`breaks.ts`). Declaring it routes `decode`
+ * through the plain path, folding a cell's `continues` lines into that paragraph.
  */
 export declare const cellSchema: Schema<"hard_break", string>;
 /**
- * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, no
- * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
- * for the reason {@link plaintextSchema} is.
- *
- * A paragraph and a break both store one `\n`, so a paragraph here is a line and
- * says so (`data-qm-line`): `prose.css` draws a run of them at the leading, and a
- * boundary reads as the one line down that a break does.
+ * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, islands or
+ * containers, the shape `Content::is_plain` admits. A paragraph and a break both store one `\n`, so
+ * a paragraph here is a line (`data-qm-line`): `prose.css` draws a run of them at the leading.
  */
 export declare const plainSchema: Schema<"text" | "doc" | "paragraph" | "hard_break", never>;
 /** The schema a leaf of the declared type mounts: `inline` narrows either type to one
@@ -46,7 +40,8 @@ export declare function isInlineSchema(schema: Schema): boolean;
 /** True for {@link blockSchema}, the one holding blocks past the paragraph: what a
  *  leaf's island, gap-cursor and slash machinery mounts on. */
 export declare function isBlockSchema(schema: Schema): boolean;
-/** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
- *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
- *  does what decode puts between a block's continued segments. */
+/**
+ * Whether `type` can hold a within-block line break, which a heading cannot (§`heading`); a `\n`
+ * landing in a textblock and decode's continued segments turn on it (`breaks.ts`).
+ */
 export declare function takesLineBreak(type: NodeType): boolean;

package/dist/core/codec/schema.js

@@ -1,43 +1,41 @@
-// The PM schema: the codec owns it; decode/encode target it. Nodes mirror the
-// content block kinds (para/heading/code/rule/island) and its container nesting
-// (list_item/quote → lists/blockquote); marks mirror the content formatting set.
-// Each set is closed upstream, so the schema names its whole vocabulary and carries
-// nothing inert. `blockSchema` is the full field; `inlineSchema` is the constrained
-// single-textblock form for a one-line `richtext` (one paragraph, no block split, no
-// containers, no islands) and `plaintextSchema` is that one without marks, for a
-// one-line `text`; `plainSchema` is a `text` field declaring `multiline: true`,
-// paragraphs and hard breaks and nothing else; `cellSchema` is the inline form with
-// hard breaks, for a table cell. Same decode/lower/position machinery,
-// narrower shapes. Anchors are not marks here (decorations).
+// The PM schema: the codec owns it; decode/encode target it. Nodes mirror the content block kinds
+// (para/heading/code/rule/island) and container nesting (list_item/quote); marks mirror the content
+// formatting set. Each set is closed upstream, so the schema names its whole vocabulary.
+// `blockSchema` is the full field; `inlineSchema` the single-textblock form for a one-line
+// `richtext`; `plaintextSchema` that without marks, for a one-line `text`; `plainSchema` a `text`
+// field declaring `multiline: true` (paragraphs and hard breaks only); `cellSchema` the inline form
+// with hard breaks, for a table cell. Anchors are not marks here (decorations).
 //
-// `toDOM` and `parseDOM` are one tier, not two halves of a rendering: a copy and a
-// paste inside one body run the whole document through them (CODEC §"Markdown at the
-// edges"), so every attribute written here is read back here. Foreign HTML spells none
-// of this package's `data-qm-*` names, so what a paste takes off the web is unchanged;
-// the rules here that widen that door on purpose are the fence's and a span's styled
-// marks, a `<table>` being the block leaf's clipboard parser's (`table-paste.ts`).
+// `toDOM` and `parseDOM` are one tier: a copy and a paste inside one body run the whole document
+// through them (CODEC §"Markdown at the edges"), so every attribute written here is read back here.
+// Foreign HTML spells none of this package's `data-qm-*` names; the rules that widen that door on
+// purpose are the fence's and a span's styled marks, a `<table>` being the block leaf's clipboard
+// parser's (`table-paste.ts`).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
 import { taskBody, taskChecked, taskDOM } from './tasks.js';
 import { rendersHref, storableUrl } from './urls.js';
 // ── Marks spelled as style ──────────────────────────────────────────────────
-// A word processor writes formatting as a span's inline style rather than as a tag:
-// Google Docs spells all four marks below that way, and wraps a whole copy in a `<b>`
-// stating a regular weight. Read off a `<span>` alone, since the same style on a cell or
-// a heading is that block's face rather than a run's. An underline inside a link is the
-// link's own: Docs underlines every one, and Chrome inlines the computed decoration on a
-// copy off any page.
+// A word processor writes formatting as a span's inline style rather than a tag: Google Docs spells
+// all four marks below that way, and wraps a whole copy in a `<b>` stating a regular weight. Read
+// off a `<span>` alone (the same style on a cell or heading is that block's face). An underline
+// inside a link is the link's own: Docs underlines every one, and Chrome inlines the computed
+// decoration on a copy.
 /** Whether `el`'s inline style states a bold weight. */
 const bold = (el) => /^(?:bold(?:er)?|[6-9]\d\d)$/.test(el.style.fontWeight);
 /** The text decoration `el` states, as a shorthand or a longhand. */
 const decoration = (el) => `${el.style.textDecoration} ${el.style.textDecorationLine}`;
-/** A mark a `<span>` carries where `styled` holds of it. Not consuming, so every mark a
- *  span states matches, and so do the span's own rules after them. */
+/**
+ * A mark a `<span>` carries where `styled` holds of it. Not consuming, so every mark a span states
+ * matches, and so do the span's own rules.
+ */
 const styledSpan = (styled) => ({
     tag: 'span',
     consuming: false,
     getAttrs: (el) => styled(el) && null
 });
+/** `s` as a CSS string literal. */
+const cssString = (s) => `"${s.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\a ')}"`;
 // ── Marks (the block and inline schemas share them; plaintext declares none) ─
 const marks = {
     // Order matters: it fixes mark-set sort order and parse precedence. `link`
@@ -74,6 +72,29 @@ const marks = {
         toDOM: () => ['s', 0]
     },
     code: { parseDOM: [{ tag: 'code' }], toDOM: () => ['code', 0] },
+    // One family a character, PM's default exclusion of a mark by its own type: a second family
+    // replaces the first, as the store's keyed `add` does. A family the page cannot draw falls to
+    // the root's face. A span styling `font-family` is the source's face, never a mark.
+    font_family: {
+        attrs: { name: { default: '' } },
+        parseDOM: [
+            {
+                tag: 'span[data-qm-family]',
+                getAttrs: (el) => {
+                    const name = el.getAttribute('data-qm-family');
+                    return name ? { name } : false;
+                }
+            }
+        ],
+        toDOM: (mark) => {
+            const name = mark.attrs.name;
+            return [
+                'span',
+                { 'data-qm-family': name, style: `font-family: ${cssString(name)}, var(--_qm-font)` },
+                0
+            ];
+        }
+    },
     link: {
         attrs: { href: { default: '' } },
         inclusive: false,
@@ -84,11 +105,8 @@ const marks = {
                 getAttrs: (el) => ({ href: storableUrl(el.getAttribute('data-qm-href') ?? '') })
             }
         ],
-        // A refused href draws as a bare span: the text stands, unstyled and
-        // unclickable, and the mark keeps its value for encode. The value rides on the
-        // span rather than going with the tag — an `href` no renderer will follow is one
-        // the document still holds, and a copy is not the explicit conversion allowed to
-        // lose it.
+        // A refused href draws as a bare span, unstyled and unclickable, and the mark keeps its
+        // value for encode: a copy is not the explicit conversion allowed to lose it.
         toDOM: (mark) => {
             const href = mark.attrs.href;
             return rendersHref(href) ? ['a', { href }, 0] : ['span', { 'data-qm-href': href }, 0];
@@ -96,15 +114,14 @@ const marks = {
     }
 };
 // ── The fence's language ────────────────────────────────────────────────────
-// Minted by the fence shorthand, which fires on Enter with the language typed after the
-// backticks (`inputrules.ts`), and by a paste, which this reads: a fence copied off a
-// highlighted page arrives carrying the language that page stated, one copied inside
-// the body keeps its own.
+// Minted by the fence shorthand (`inputrules.ts`) and by a paste: a fence copied off a highlighted
+// page carries the page's language, one copied inside the body keeps its own.
 /** A `language-x` / `lang-x` token in a class list. */
 const LANG_CLASS = /(?:^|\s)lang(?:uage)?-(\S+)/;
-/** The language a `<pre>` states: `data-lang`, which is what `toDOM` writes, else the
- *  class convention on the `pre` or on the `code` it wraps. `null` where it states
- *  none, which is also what an empty value is. */
+/**
+ * The language a `<pre>` states: `data-lang` (what `toDOM` writes), else the class convention on
+ * the `pre` or its `code`. `null` for none or an empty value.
+ */
 function fenceLang(pre) {
     const stated = pre.getAttribute('data-lang');
     if (stated)
@@ -125,10 +142,9 @@ const blockNodes = {
         parseDOM: [{ tag: 'p' }],
         toDOM: () => ['p', 0]
     },
-    // A heading holds no `hard_break`: it is a block of one line, so the store clears a
-    // `continues` after one and markdown has no syntax for a break inside it. Declaring
-    // it out is what makes that structural — a paste parses the `<br>` away and a
-    // conversion onto a heading drops it, rather than each door holding the rule.
+    // A heading holds no `hard_break`: the store clears a `continues` after one and markdown has no
+    // syntax for a break inside it. Declaring it out makes that structural rather than a rule each
+    // door holds.
     heading: {
         content: '(text | island_inline)*',
         group: 'block',
@@ -174,12 +190,11 @@ const blockNodes = {
             {
                 tag: 'ol',
                 getAttrs: (el) => {
-                    // A list stating no `start` starts at one, the absence `toDOM` writes for
-                    // it; `Number(null)` would read that absence as zero. A value the store
-                    // would normalize away reads as that absence too: the leaf re-hydrates
-                    // only on an external change (CODEC §Reconciliation), so a PM doc keeping
-                    // one disagrees with the store for the rest of the session. Zero is not
-                    // one — `0.` is an ordinal `importMarkdown` produces and the store keeps.
+                    // A list stating no `start` starts at one, the absence `toDOM` writes;
+                    // `Number(null)` would read it as zero. A value the store would normalize away
+                    // reads as that absence too, since a PM doc keeping one would disagree with the
+                    // store for the session (CODEC §Reconciliation). Zero is not one: `0.` is an
+                    // ordinal `importMarkdown` produces.
                     const stated = el.getAttribute('start');
                     const start = stated ? Number(stated) : 1;
                     return { start: Number.isSafeInteger(start) && start >= 0 ? start : 1 };
@@ -213,9 +228,8 @@ const blockNodes = {
 // ── Inline nodes ────────────────────────────────────────────────────────────
 const inlineLeafNodes = {
     text: { group: 'inline' },
-    // `linebreakReplacement` is what makes a join across a `code_block`'s edge
-    // lossless: `Transform.join` and `setBlockType` convert its `\n`s to breaks
-    // rather than flattening them to spaces, and a break is a `continues` line.
+    // `linebreakReplacement` makes a join across a `code_block`'s edge lossless: `Transform.join`
+    // and `setBlockType` convert its `\n`s to breaks, which are `continues` lines.
     hard_break: {
         inline: true,
         group: 'inline',
@@ -231,45 +245,38 @@ export const blockSchema = new Schema({
     nodes: { ...blockNodes, ...inlineLeafNodes },
     marks
 });
-// ── The constrained inline nodes (the inline schemas and the cell's) ────
-// `doc: "paragraph"` (exactly one child) is what makes an Enter a no-op at the
-// model level: there is no second block for a split to land.
+// `doc: "paragraph"` (exactly one child) makes Enter a no-op at the model level: no second block
+// for a split to land.
 const inlineNodes = {
     doc: { content: 'paragraph' },
     paragraph: { content: 'inline*', toDOM: () => ['p', 0] },
     text: { group: 'inline' }
 };
-/** The constrained inline schema: one paragraph, no block splitting, no
- *  containers, no islands, and the full mark set (a `richtext(inline)` field). */
+/**
+ * The constrained inline schema: one paragraph, no containers or islands, the full mark set (a
+ * `richtext(inline)` field).
+ */
 export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
 /**
- * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
- * value is literal text the boundary refuses to coerce back once it carries a mark.
- *
- * Declaring none is what makes that structural rather than a rule each path
- * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
- * a paste parses its marks away, and `decode` drops any a stray content arrives
- * carrying (CODEC §Inline mode).
+ * The inline schema with no mark types: a `plaintext(inline)` field, whose value is literal text
+ * the boundary refuses to coerce back once it carries a mark. Declaring none makes that structural:
+ * `toggleMark` has no type, the mark input rules build nothing, a paste parses marks away, and
+ * `decode` drops any a stray content carries (CODEC §Inline mode).
  */
 export const plaintextSchema = new Schema({ nodes: inlineNodes, marks: {} });
 /**
- * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a
- * `\n` in its `text`. Still one paragraph, so Enter has no block to split; a break is
- * Shift-Enter's (`breaks.ts`). Declaring the break routes `decode` through the plain
- * path, which folds a cell's `continues` lines into that one paragraph.
+ * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a `\n` in its
+ * `text`. Still one paragraph; a break is Shift-Enter's (`breaks.ts`). Declaring it routes `decode`
+ * through the plain path, folding a cell's `continues` lines into that paragraph.
  */
 export const cellSchema = new Schema({
     nodes: { ...inlineNodes, hard_break: inlineLeafNodes.hard_break },
     marks
 });
 /**
- * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, no
- * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
- * for the reason {@link plaintextSchema} is.
- *
- * A paragraph and a break both store one `\n`, so a paragraph here is a line and
- * says so (`data-qm-line`): `prose.css` draws a run of them at the leading, and a
- * boundary reads as the one line down that a break does.
+ * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, islands or
+ * containers, the shape `Content::is_plain` admits. A paragraph and a break both store one `\n`, so
+ * a paragraph here is a line (`data-qm-line`): `prose.css` draws a run of them at the leading.
  */
 export const plainSchema = new Schema({
     nodes: {
@@ -301,9 +308,10 @@ export function isInlineSchema(schema) {
 export function isBlockSchema(schema) {
     return !!schema.nodes.blockquote;
 }
-/** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
- *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
- *  does what decode puts between a block's continued segments. */
+/**
+ * Whether `type` can hold a within-block line break, which a heading cannot (§`heading`); a `\n`
+ * landing in a textblock and decode's continued segments turn on it (`breaks.ts`).
+ */
 export function takesLineBreak(type) {
     const br = type.schema.nodes.hard_break;
     return !!br && type.contentMatch.matchType(br) !== null;