@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/core/inline/format-toggle.js

@@ -1,43 +1,42 @@
 /**
- * Toggle an inline format inside a prose block. Over a SELECTION the direction is parse coverage,
- * not edge adjacency: a covered range unapplies (aligned strip, else split, over every covering run
- * in turn), overlapping or abutting runs apply over their union, a bare range wraps the core its
- * boundary whitespace leaves. Where the mode PAINTS delimiters the strip and the wrap write
- * unverified; every other candidate declines unless it verifies. At a COLLAPSED CARET: unwrap the
- * span, else drop the empty pair, else insert one (live-mode.md § 4.3). Every write clamps to the
- * CONTENT range: a marker in `# ` changes the kind.
+ * Toggles an inline mark inside a prose block, and answers whether a range already carries one.
+ * The parse decides the direction; in a mode that hides markers a candidate must leave the screen
+ * text unchanged (`docs/design/live-mode.md` § 2, and § 4.3 for a collapsed caret). Writes stay
+ * inside the content range, since a marker written into `# ` would change the block's kind.
  */
 import { recordFormatCoverageRead } from '../../perf/instruments';
-import { paintsFocusedMarkers } from '../../presentation-mode';
 import { getInlineMarkPolicy, listInlineMarks } from '../../schema/inline-construct-policy';
-import { constructContentRange, inlineDescendants, parseInline } from './index';
+import { constructContentRange, inlineDescendants, readInline } from './index';
 import { CONTENT_VISIBILITY, renderedText } from './visibility';
-/** Null for a kind whose row declares no mark, or for a press whose every candidate fails its
- *  verification: the vocabulary lives on the row, so a kind without one has no delimiters this
- *  seam could write, and a toggle's sound fallback is not writing. */
-export function toggleInlineFormat(edit, format, mode) {
+/** Null for a kind whose policy row declares no mark (there are no delimiters to write) and for
+ *  a toggle whose every candidate fails verification: the safe fallback is to write nothing. */
+export function toggleInlineFormat(edit, format) {
     const mark = getInlineMarkPolicy(format);
     if (!mark)
         return null;
     const { display, content, selection } = edit;
     const start = clampToContent(selection.start, content);
     const end = clampToContent(selection.end, content);
-    // The same bounds the block itself parses with, so no construct can straddle the structural
+    // Parsed with the block's own content bounds, so no construct can straddle the structural
     // bytes the clamp above keeps the write out of.
-    const inlines = parseInline(display, content.start, content.end);
+    const inlines = readInline(display, content.start, content.end, edit.reading.resolver, edit.reading.grammar);
     if (start === end)
         return toggleAtCaret(display, inlines, start, format, mark);
-    // Painted delimiters are the mode's own answer, so those modes write their candidate unverified.
-    // The preview rungs paint: this seam only writes into the block those rungs reveal.
-    const paints = paintsFocusedMarkers(mode ?? 'source');
+    // A mode that shows the delimiters writes its candidate unverified: the user sees the markers.
+    // The preview modes count as showing them, since a toggle only writes into the focused block.
+    const paints = !edit.reading.hidesDelimitersAtCaret();
     const { from, to, covering } = coveredReading(display, inlines, start, end, format);
-    // A strip sheds ONE run, so where a second of the same kind covers the selection too, the answer
-    // is the covering arm's split: stripping there leaves the press's own read still active.
-    const sole = covering.length > 1 ? null : soleStripCandidate(display, inlines, from, to, format);
+    // A strip removes one run, so when a second run of the same kind also covers the selection the
+    // split path below handles it: stripping alone would leave the format still active.
+    const sole = covering.length > 1
+        ? null
+        : soleStripCandidate(display, inlines, from, to, format, edit.reading);
     if (sole)
-        return paints || preservesScreen(sole, edit, screenOf(display, content)) ? sole : null;
-    // The flank strip rewrites bytes OUTSIDE the selection, and byte equality can mistake a nested
-    // run's delimiters for the enclosing one's, so its candidate verifies like the split's.
+        return paints || preservesScreen(sole, edit, screenOf(display, content, edit.reading))
+            ? sole
+            : null;
+    // The flank strip rewrites bytes outside the selection, and byte equality can mistake a nested
+    // run's delimiters for the enclosing one's, so its candidate is verified like the split's.
     const enclosing = enclosingSpanOf(inlines, from, to, format);
     if (enclosing && flanksAreItsMarkers(display, from, to, enclosing)) {
         const flank = firstFlipVerified([flankStrip(display, from, to, enclosing)], edit, format, 'unapply');
@@ -49,36 +48,34 @@ export function toggleInlineFormat(edit, format, mode) {
     const union = formatUnionOf(inlines, start, end, format);
     if (union)
         return firstFlipVerified(absorbCandidates(display, inlines, union, { start, end }, format, mark), edit, format, 'apply');
-    // A wrap whose markers do not paint owes split and absorb's coverage check: bytes that re-pair
-    // against a neighbouring run leave the range unformatted with nothing on screen to say so.
+    // A wrap with hidden markers is verified like split and absorb: markers that re-pair with a
+    // neighbouring run leave the range unformatted, with nothing on screen to show it.
     const wrap = wrapCandidate(display, inlines, start, end, mark);
     if (!wrap)
         return null;
     return paints ? wrap : firstFlipVerified([wrap], edit, format, 'apply');
 }
-/** Whether a toggle right now would UNAPPLY — the pressed-state a toolbar paints. The same arms
- *  the toggle routes by, asked without emitting: a caret inside the construct, a selection
- *  carrying its own markers, flanked by them, or covered by a same-format construct. */
+/** Whether a toggle right now would unformat, which is the pressed state a toolbar shows. The
+ *  same checks the toggle routes by, asked without writing anything. */
 export function isInlineFormatActive(edit, format) {
     return coverageCarries(coverageOf(edit), format);
 }
-/** The pressed state a result would paint: the same read, over the bytes and range it hands back.
- *  One home for the after-read, so the seam's own direction check and the ladder guard cannot
- *  drift on the content-end arithmetic. */
+/** The same read over the bytes and range `result` hands back, kept here so the toggle's direction
+ *  check and the tests that re-read a result agree on where the content ends. */
 export function isInlineFormatActiveAfter(edit, result, format) {
     return isInlineFormatActive({
         display: result.newDisplay,
         content: shiftedContent(edit.content, edit.display, result),
-        selection: { start: result.newSelStart, end: result.newSelEnd }
+        selection: { start: result.newSelStart, end: result.newSelEnd },
+        reading: edit.reading
     }, format);
 }
 /** Every registered mark the edit's range already carries. */
 export function activeInlineFormats(edit) {
     return inlineFormatsCovering(edit, listInlineMarks().map((entry) => entry.kind));
 }
-/** Which of `candidates` the range carries, off ONE parse of the block. A toolbar asks once per
- *  button on every selection change and every answer is the same walk; taking candidates rather
- *  than the vocabulary is what lets a range's running intersection stop re-asking ruled-out marks. */
+/** One parse of the block for every candidate. A toolbar asks per button on each selection
+ *  change, so a caller can leave out marks it has already ruled out. */
 export function inlineFormatsCovering(edit, candidates) {
     const coverage = coverageOf(edit);
     const carried = new Set();
@@ -87,14 +84,16 @@ export function inlineFormatsCovering(edit, candidates) {
             carried.add(kind);
     return carried;
 }
-/** The same read, one id at a time, with consecutive asks over one block state sharing the parse:
- *  a toolbar's buttons arrive as N separate calls, and only the caller knows they are one repaint.
- *  One slot, since the previous state is dead the moment a keystroke or the caret moves. */
+/** Shares one parse across a toolbar's per-button calls over the same block state. One memo
+ *  entry only, since a keystroke or a caret move retires the previous state. */
 export function createInlineFormatActiveMemo() {
+    // The resolver is kept apart from the edit because the editor's ref reads it through a getter,
+    // so a definition edited elsewhere changes it under the same ref.
     let slot = null;
     return (edit, format) => {
-        if (!slot || !sameEdit(slot.edit, edit))
-            slot = { edit, coverage: coverageOf(edit) };
+        const resolver = edit.reading.resolver;
+        if (!slot || slot.resolver !== resolver || !sameEdit(slot.edit, edit))
+            slot = { edit, resolver, coverage: coverageOf(edit) };
         return coverageCarries(slot.coverage, format);
     };
 }
@@ -103,9 +102,9 @@ function coverageOf(edit) {
     const { display, content, selection } = edit;
     const start = clampToContent(selection.start, content);
     const end = clampToContent(selection.end, content);
-    const inlines = parseInline(display, content.start, content.end);
-    // A selection spanning the whole display is the same parse, byte bounds included — which is
-    // every middle block of a cross-block range, so the second parse is worth not making.
+    const inlines = readInline(display, content.start, content.end, edit.reading.resolver, edit.reading.grammar);
+    // A selection spanning the whole display parses the same as the block, and that is every
+    // middle block of a cross-block range, so the second parse is skipped.
     const sliceIsDisplay = start === 0 && end === display.length;
     return {
         display,
@@ -116,20 +115,21 @@ function coverageOf(edit) {
             ? []
             : sliceIsDisplay
                 ? inlines
-                : parseInline(display.slice(start, end), 0, end - start)
+                : readInline(display.slice(start, end), 0, end - start, edit.reading.resolver, edit.reading.grammar)
     };
 }
-/** The memo's key: field-wise, where the cross-block sibling composes a string, because the
- *  display here is the block's whole raw and building a key would cost what the memo saves. */
+/** Field-wise comparison rather than a composed string key: the display is the block's whole raw,
+ *  and building a key would cost what the memo saves. */
 function sameEdit(a, b) {
     return (a.display === b.display &&
         a.content.start === b.content.start &&
         a.content.end === b.content.end &&
         a.selection.start === b.selection.start &&
-        a.selection.end === b.selection.end);
+        a.selection.end === b.selection.end &&
+        a.reading.grammar === b.reading.grammar);
 }
-/** The one home for "does this range carry this mark", so every reader asks the same guards —
- *  including the mark-row test, which a kind with no vocabulary has to fail rather than parse. */
+/** The one place that answers "does this range carry this mark", so every reader applies the same
+ *  checks, including the policy-row test a kind with no mark must fail without parsing. */
 function coverageCarries({ display, start, end, inlines, sliceNodes }, format) {
     if (!getInlineMarkPolicy(format))
         return false;
@@ -142,11 +142,8 @@ function coverageCarries({ display, start, end, inlines, sliceNodes }, format) {
         return true;
     return coveredReading(display, inlines, start, end, format).covering.length > 0;
 }
-/**
- * The range an unapply reads, with the runs covering it. A run closes against a word and never
- * whitespace, so the wrap leaves a boundary space OUTSIDE the delimiters: a selection reaching
- * past a run by whitespace alone is still that run's own, or it could not take its own mark off.
- */
+/** A run closes against a word, never whitespace, so a selection reaching past a run by
+ *  whitespace alone still counts as that run, or it could not take its own mark off. */
 function coveredReading(display, inlines, start, end, format) {
     const covering = coveringSpansOf(inlines, start, end, format);
     if (covering.length > 0)
@@ -160,13 +157,11 @@ function coveredReading(display, inlines, start, end, format) {
         : { from: start, to: end, covering };
 }
 // ── Aligned unapply ──────────────────────────────────────────────────────────
-/** The selection carries its own flanking markers (the user selected `**word**`): exactly one
- *  span covering the whole slice, so the strip can't orphan markers on `**a** **b**`. It rewrites
- *  only selected bytes, so it keeps the press's literal reading, and it sheds the runs of its own
- *  kind inside that reading, or a whole-range unapply would leave part of the range formatted. */
-function soleStripCandidate(display, inlines, start, end, format) {
+/** For a selection holding its own markers (`**word**`), covered by exactly one span so that
+ *  `**a** **b**` keeps its markers. Nested same-kind runs go too, or part stays formatted. */
+function soleStripCandidate(display, inlines, start, end, format, reading) {
     const slice = display.slice(start, end);
-    const sliceNodes = parseInline(slice, 0, slice.length);
+    const sliceNodes = readInline(slice, 0, slice.length, reading.resolver, reading.grammar);
     const selfSpan = soleSpanOfSelection(sliceNodes, inlines, start, end, format);
     if (!selfSpan)
         return null;
@@ -177,9 +172,8 @@ function soleStripCandidate(display, inlines, start, end, format) {
         newSelEnd: start + unwrapped.length
     };
 }
-/** Markers outside the selection (`word` inside `*word*`), stripped at the selection's flanks
- *  rather than the construct's own run, so a `***word***` stack sheds one layer by run
- *  arithmetic; the construct check is what makes `**word**` toggled to emphasis nest instead. */
+/** Markers just outside the selection (`word` in `*word*`) are cut at the selection's edges, not
+ *  at the construct's own run, so `***word***` loses one layer. */
 function flankStrip(display, start, end, span) {
     const mLen = markerLengthOf(span);
     return {
@@ -189,12 +183,8 @@ function flankStrip(display, start, end, span) {
     };
 }
 // ── Split unapply ────────────────────────────────────────────────────────────
-/**
- * The construct re-emitted around the selection: each non-empty half keeps the construct's own
- * delimiter run, and a half's boundary whitespace yields a second candidate with it moved outside,
- * since the symmetric runs cannot close against a space. The middle sheds the markers of any
- * same-format construct it wholly contains, or it would reload still formatted.
- */
+/** Each non-empty half keeps its delimiters, plus a candidate with boundary spaces moved out, as a
+ *  run cannot close on a space. The middle loses nested same-format markers, or stays formatted. */
 function splitCandidates(display, inlines, span, start, end, format) {
     const cutStart = Math.max(start, span.contentStart);
     const cutEnd = Math.min(end, span.contentEnd);
@@ -234,11 +224,8 @@ function halfVariants(text, opener, closer) {
     ];
 }
 // ── Absorb apply ─────────────────────────────────────────────────────────────
-/**
- * The selection grown over every same-format construct it touches, to a fixed point. Only
- * recursive-content constructs join: one holding literal text (a code span) means its delimiters
- * are honest content inside any wider span, so merging would rewrite what the reader sees.
- */
+/** Grows to a fixed point over the same-format constructs the selection touches. Only ones with
+ *  children join: inside a wider span a code span's delimiters would show as literal text. */
 function formatUnionOf(inlines, start, end, format) {
     const spans = [];
     for (const node of inlineDescendants(inlines)) {
@@ -267,9 +254,8 @@ function formatUnionOf(inlines, start, end, format) {
     }
     return touched ? { start: from, end: to } : null;
 }
-/** The run grows to the union, the SELECTION does not: each endpoint is carried through the
- *  strip and re-wrap, so a press over half a run leaves that half selected. An endpoint on the
- *  union's edge keeps the new marker inside the range, as a bare wrap's selection does. */
+/** The run grows to the union but the selection does not: each endpoint is tracked through the
+ *  strip and re-wrap, so a toggle over half a run leaves that half selected. */
 function absorbCandidates(display, inlines, union, selected, format, mark) {
     if (!cutsLandCleanly(inlines, union, union))
         return [];
@@ -307,10 +293,8 @@ function absorbCandidates(display, inlines, union, selected, format, mark) {
         out.push(wrapAt(lead, stripped.slice(lead.length, stripped.length - trail.length), trail));
     return out;
 }
-/** Whether a rewrite of `within` may splice at both `cuts`: each has to land where a byte splice
- *  can, in a text run or on a construct boundary, never strictly inside another construct's bytes —
- *  a stranded delimiter re-pairs with whatever run the parse finds next, which can preserve the
- *  text while reformatting content nobody selected. Split, absorb and the wrap all ask here. */
+/** Each cut must fall in a text run or on a construct boundary: a delimiter stranded inside a
+ *  construct re-pairs with the next run the parse finds, formatting content nobody selected. */
 function cutsLandCleanly(inlines, cuts, within) {
     for (const node of inlineDescendants(inlines)) {
         if (node.kind === 'text')
@@ -352,7 +336,7 @@ function spliceOutCuts(display, cuts, from, to) {
     return out + display.slice(at, to);
 }
 /** Where a display offset lands in the stripped slice: the cut bytes before it fall away, and an
- *  offset inside a marker rides to that marker's start. */
+ *  offset inside a marker moves to that marker's start. */
 function strippedOffset(cuts, from, offset) {
     let removed = 0;
     for (const [cutFrom, cutTo] of cuts)
@@ -361,12 +345,8 @@ function strippedOffset(cuts, from, offset) {
     return Math.max(0, offset - from - removed);
 }
 // ── Wrap ─────────────────────────────────────────────────────────────────────
-/**
- * The bare wrap, over the selection's trimmed core: markdown opens and closes a run against a word,
- * never whitespace, so a boundary space goes to the plain text beside the run, as
- * `live-split-rebalance` reads the same problem. Null where nothing survives the trim, or where an
- * endpoint is no legal cut: markers spliced into a construct's bytes re-pair.
- */
+/** Boundary spaces stay outside the markers, since a run opens and closes against a word. Null
+ *  when nothing survives the trim or an endpoint would cut into a construct. */
 function wrapCandidate(display, inlines, start, end, mark) {
     const core = withoutBoundaryWhitespace(display, start, end);
     if (!core || !cutsLandCleanly(inlines, core, core))
@@ -384,27 +364,28 @@ function wrapRange(display, start, end, mark) {
 // ── Verification ─────────────────────────────────────────────────────────────
 /** A toggle changes formatting, never the text on screen, so the render path's own reading of the
  *  content is what a candidate has to leave unchanged (live-mode.md § 2). */
-function screenOf(display, content) {
-    return renderedText(parseInline(display, content.start, content.end), display, CONTENT_VISIBILITY);
+function screenOf(display, content, reading) {
+    return renderedText(readInline(display, content.start, content.end, reading.resolver, reading.grammar), display, CONTENT_VISIBILITY, { grammar: reading.grammar });
 }
 function preservesScreen(candidate, edit, shown) {
     const { display, content } = edit;
-    return screenOf(candidate.newDisplay, shiftedContent(content, display, candidate)) === shown;
+    const shifted = shiftedContent(content, display, candidate);
+    return screenOf(candidate.newDisplay, shifted, edit.reading) === shown;
 }
-/** Both checks a candidate owes wherever its own bytes are not the mode's answer: the content text
- *  unchanged, and the selection's coverage actually flipped — text preservation alone admits a
- *  nested pair that leaves the range formatted exactly as it was. */
+/** The screen text must be unchanged and the coverage must actually flip: text preservation
+ *  alone admits a nested pair that leaves the range formatted exactly as it was. */
 function firstFlipVerified(candidates, edit, format, direction) {
     const { display, content } = edit;
-    const shown = screenOf(display, content);
+    const shown = screenOf(display, content, edit.reading);
     return (candidates.find((candidate) => preservesScreen(candidate, edit, shown) &&
-        coverageFlipped(candidate, shiftedContent(content, display, candidate), format, direction)) ?? null);
+        coverageFlipped(candidate, edit, format, direction)) ?? null);
 }
-/** Whether NO same-format run is left overlapping the selection, or one covers it whole — the
- *  press's direction, asked of the bytes it would write. */
-function coverageFlipped(candidate, content, format, direction) {
+/** Whether the toggle's direction holds in the bytes it would write: for apply, a same-format run
+ *  covers the selection whole; for unapply, none still overlaps it. */
+function coverageFlipped(candidate, edit, format, direction) {
     const { newDisplay, newSelStart: from, newSelEnd: to } = candidate;
-    const inlines = parseInline(newDisplay, content.start, content.end);
+    const content = shiftedContent(edit.content, edit.display, candidate);
+    const inlines = readInline(newDisplay, content.start, content.end, edit.reading.resolver, edit.reading.grammar);
     if (direction === 'apply')
         return coveringSpansOf(inlines, from, to, format).length > 0;
     const spans = [];
@@ -413,7 +394,7 @@ function coverageFlipped(candidate, content, format, direction) {
             spans.push({ start: node.start, end: node.end });
     return spans.every((span) => span.end <= from || to <= span.start);
 }
-/** The write clamps into the content, so only its END moves, by what the candidate added. */
+/** The write stays inside the content range, so only its end moves, by what the candidate added. */
 function shiftedContent(content, display, candidate) {
     return { start: content.start, end: content.end + candidate.newDisplay.length - display.length };
 }
@@ -432,10 +413,8 @@ function toggleAtCaret(display, inlines, caret, format, mark) {
     }
     const markers = mark.markerBytes;
     const mLen = markers.length;
-    // The empty pair the previous press inserted; there is no span to find, since `****` parses as
-    // literal text. Removal is the exact inverse of the insert below, so the pair must be a run of
-    // its own: a marker character abutting either side means these are bytes the user wrote, and
-    // this arm only runs where the mode paints them.
+    // An empty pair from a previous toggle, which parses as literal text (`****`). A marker
+    // character beside the pair means the user wrote these bytes, so only a lone pair goes.
     if (isLoneEmptyPair(display, caret, markers)) {
         return {
             newDisplay: display.slice(0, caret - mLen) + display.slice(caret + mLen),
@@ -460,8 +439,8 @@ function isLoneEmptyPair(display, caret, markers) {
         display[start - 1] !== markers[0] &&
         display[caret + mLen] !== markers[mLen - 1]);
 }
-/** Both delimiters of a construct are the same run, so the bytes its content leaves over split
- *  evenly — which is how a code span's content-sized fence is read back off the parse. */
+/** Both delimiters of a construct are the same run, so the bytes outside its content split evenly;
+ *  a code span's fence comes from `codeSpanFence`, through {@link constructContentRange}. */
 function markerLengthOf(span) {
     return span.contentStart - span.start;
 }
@@ -471,11 +450,8 @@ function spanOf(node) {
         return null;
     return { start: node.start, end: node.end, contentStart: content.start, contentEnd: content.end };
 }
-/**
- * The innermost construct of this kind whose CONTENT covers `[start, end]`, off the FULL-context
- * parse: `*word*` carved from `**word**` and from `***word***` read identically in isolation, but
- * only the latter sits inside an emphasis span.
- */
+/** The innermost, from the block's full parse: `*word*` cut from `**word**` or from `***word***`
+ *  reads the same alone, but only the latter sits inside an emphasis span. */
 function enclosingSpanOf(inlines, start, end, format) {
     let found = null;
     for (const node of inlineDescendants(inlines)) {
@@ -487,10 +463,8 @@ function enclosingSpanOf(inlines, start, end, format) {
     }
     return found;
 }
-/** Every construct of this kind whose WHOLE RANGE covers the selection, peeled of the delimiters
- *  the selection takes whole — coverage that reaches into the delimiters still reads as "already
- *  formatted", and where runs of one kind nest, shedding the inner one leaves the outer covering,
- *  so the split tries each in turn. */
+/** A selection reaching into the delimiters still reads as formatted. Every nested run of the
+ *  kind is returned, since removing the inner one leaves the outer covering. */
 function coveringSpansOf(inlines, start, end, format) {
     const range = peeledToContent(inlines, start, end);
     const covering = [];
@@ -503,9 +477,8 @@ function coveringSpansOf(inlines, start, end, format) {
     }
     return covering;
 }
-/** The range with the delimiters of every construct it takes WHOLE peeled off: a run nests inside
- *  another kind's bytes (`***ab***` is emphasis around strong), so a range that takes the outer
- *  construct whole is asking about the content that construct encloses. */
+/** A run can nest inside another kind's bytes (`***ab***` is emphasis around strong), so a range
+ *  taking the outer construct whole is asking about the content inside it. */
 function peeledToContent(inlines, start, end) {
     let from = start;
     let to = end;
@@ -530,12 +503,8 @@ function spanExactlyOver(inlines, start, end) {
     }
     return null;
 }
-/**
- * The selection read as exactly one span of this kind — standalone AND in the block's own parse,
- * which is the only reading a strip may act on: `*bold*` carved out of `**bold**` is emphasis alone
- * while the block holds none, and shedding one delimiter layer there lands on a run of the same
- * kind. Offsets come back in SLICE space, where the strip splices.
- */
+/** Both parses must agree before a strip: `*bold*` cut from `**bold**` is emphasis alone but not
+ *  in the block. Offsets are relative to the slice, where the strip splices. */
 function soleSpanOfSelection(sliceNodes, inlines, start, end, format) {
     const span = soleSpanIn(sliceNodes, end - start, format);
     if (!span)
@@ -569,9 +538,8 @@ function leadingWs(text) {
 function trailingWs(text) {
     return /\s*$/.exec(text)[0];
 }
-/** A range minus its boundary whitespace, null once nothing is left. One home for the trim, so the
- *  wrap here and the cross-block decomposition that trims before it ever asks
- *  (`selection/cross-block/format-range.ts`) cannot disagree about where a run may close. */
+/** Shared with the cross-block path (`selection/cross-block/format-range.ts`) so the two agree
+ *  on where a run may close. Null when nothing is left. */
 export function withoutBoundaryWhitespace(display, from, to) {
     let start = from;
     let end = to;

package/dist/core/inline/html-entities.d.ts

@@ -1,8 +1,7 @@
 /**
  * HTML5 named-entity table per CommonMark §2.5, vendored from
  * https://html.spec.whatwg.org/entities.json (WHATWG HTML Standard, CC BY 4.0; see
- * THIRD-PARTY-NOTICES.md). To regenerate: keep only entries whose key ends with `;`
- * (CommonMark requires it), then map key-without-`&`/`;` to the whole `characters` field,
- * which is multi-codepoint for some entries.
+ * THIRD-PARTY-NOTICES.md). To regenerate: keep only keys ending in `;`, as CommonMark requires,
+ * and map each key without `&`/`;` to its whole `characters` field (some are multi-codepoint).
  */
 export declare const HTML5_NAMED_ENTITIES: Readonly<Record<string, string>>;

package/dist/core/inline/html-entities.js

@@ -1,9 +1,8 @@
 /**
  * HTML5 named-entity table per CommonMark §2.5, vendored from
  * https://html.spec.whatwg.org/entities.json (WHATWG HTML Standard, CC BY 4.0; see
- * THIRD-PARTY-NOTICES.md). To regenerate: keep only entries whose key ends with `;`
- * (CommonMark requires it), then map key-without-`&`/`;` to the whole `characters` field,
- * which is multi-codepoint for some entries.
+ * THIRD-PARTY-NOTICES.md). To regenerate: keep only keys ending in `;`, as CommonMark requires,
+ * and map each key without `&`/`;` to its whole `characters` field (some are multi-codepoint).
  */
 export const HTML5_NAMED_ENTITIES = Object.freeze({
     AElig: 'Æ',

package/dist/core/inline/html-tag-grammar.js

@@ -4,8 +4,12 @@
  * The tag sources are exported so the block parser anchors them at line scope rather than
  * keeping a copy that could drift.
  */
-const OPEN_TAG = /<[A-Za-z][A-Za-z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|"[^"]*"|'[^']*'))?)*\s*\/?>/;
-const CLOSE_TAG = /<\/[A-Za-z][A-Za-z0-9-]*\s*>/;
+import { WHITESPACE_CHARS, WHITESPACE_CLASS } from '../lines';
+// `W` is GFM whitespace (§2.1), so a non-breaking space inside a tag makes it no tag.
+const W = WHITESPACE_CLASS;
+const UNQUOTED_VALUE = `[^${WHITESPACE_CHARS}"'=<>\`]+`;
+const OPEN_TAG = new RegExp(`<[A-Za-z][A-Za-z0-9-]*(?:${W}+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:${W}*=${W}*(?:${UNQUOTED_VALUE}|"[^"]*"|'[^']*'))?)*${W}*\\/?>`);
+const CLOSE_TAG = new RegExp(`<\\/[A-Za-z][A-Za-z0-9-]*${W}*>`);
 /** Open tag `<name (attrs)* /?>` (CommonMark §6.6), unanchored source. */
 export const OPEN_TAG_SOURCE = OPEN_TAG.source;
 /** Close tag `</name>` with optional whitespace before `>`, unanchored source. */

package/dist/core/inline/image-dimensions.d.ts

@@ -7,3 +7,5 @@ export interface ParsedImageAlt {
     crop: ImageCrop | undefined;
 }
 export declare function parseImageDimensions(alt: string): ParsedImageAlt;
+/** The suffix `parseImageDimensions` reads back as these values; empty for no width. */
+export declare function buildDimSuffix(width: number | undefined, height: number | undefined, crop: ImageCrop | undefined): string;

package/dist/core/inline/image-dimensions.js

@@ -1,11 +1,13 @@
-// `|N` / `|NxM` is an Obsidian extension, not part of GFM. The `@X,Y[,Z]` tail on the `NxM`
-// form is this editor's own: the pan and zoom of the image inside that frame.
+// The size hint at the end of an image's alt text, read and written here. `|N` / `|NxM` is an
+// Obsidian extension, not part of GFM; the `@X,Y[,Z]` tail on the `NxM` form is this editor's
+// own: the pan and zoom of the image inside that frame.
 const MAX_DIMENSION = 10000;
 export const MAX_CROP_ZOOM = 4;
 // The longest decodable suffix, `|10000x10000@100,100,4.00`. Bounding the pipe search to that
 // tail keeps nested-label floods linear.
 const MAX_SUFFIX_SEARCH = 26;
 const NO_HINT = { width: undefined, height: undefined, crop: undefined };
+// ── Reading ─────────────────────────────────────────────────────────────────
 export function parseImageDimensions(alt) {
     const lastPipe = boundedLastPipe(alt);
     const dims = lastPipe === -1 ? null : parseDimensionSuffix(alt.slice(lastPipe + 1));
@@ -76,3 +78,18 @@ function parseStrictInt(s) {
         return null;
     return n;
 }
+// ── Writing ─────────────────────────────────────────────────────────────────
+/** The suffix `parseImageDimensions` reads back as these values; empty for no width. */
+export function buildDimSuffix(width, height, crop) {
+    if (width === undefined)
+        return '';
+    if (height === undefined)
+        return `|${width}`;
+    return `|${width}x${height}${crop ? buildCropTail(crop) : ''}`;
+}
+/** The pan in whole percents, then the zoom to two decimals, left out at 1. */
+function buildCropTail(crop) {
+    const z = Math.round(crop.z * 100) / 100;
+    const zoom = z === 1 ? '' : `,${String(z)}`;
+    return `@${Math.round(crop.x)},${Math.round(crop.y)}${zoom}`;
+}

package/dist/core/inline/image-source-bytes.d.ts

@@ -0,0 +1,11 @@
+import type { ImageFields, InlineNode } from '../nodes';
+/** Bytes to splice over `image`'s range, or null when the edit is refused. A node a plugin's
+ *  syntax owns is written by its `rewriteImage` hook (`docs/design/plugin-contract.md`). */
+export declare function buildImageEditBytes(image: InlineNode, blockRaw: string, fields: ImageFields): string | null;
+/** Only the optional keys the node holds, so a rebuild adds no field the source lacked and
+ *  repeated resizes leave the alt text unchanged. */
+export declare function imageFieldsFromInline(image: InlineNode): ImageFields;
+export declare function sameImageFields(a: ImageFields, b: ImageFields): boolean;
+/** The inverse of the built-in grammar; call `buildImageEditBytes`, which decides whether the
+ *  bytes are GFM's to write. */
+export declare function buildImageSourceBytes(fields: ImageFields): string;

package/dist/core/inline/image-source-bytes.js

@@ -0,0 +1,71 @@
+// Where an image edit becomes bytes: the one function every image write goes through, and
+// below it the GFM serializer, which nothing else may call.
+import { encodeDestination, escapeTitle } from './destination-bytes';
+import { buildDimSuffix } from './image-dimensions';
+import { devWarn } from '../../dev-warn';
+// ── Where the bytes are written ─────────────────────────────────────────────
+/** Bytes to splice over `image`'s range, or null when the edit is refused. A node a plugin's
+ *  syntax owns is written by its `rewriteImage` hook (`docs/design/plugin-contract.md`). */
+export function buildImageEditBytes(image, blockRaw, fields) {
+    const claim = image.syntaxClaim;
+    if (!claim)
+        return buildImageSourceBytes(fields);
+    const bytes = claim.rewriteImage?.(blockRaw.slice(image.start, image.end), fields) ?? null;
+    if (bytes === null) {
+        devWarn('image-edit', `declined: the "${claim.prefix}" inline syntax handler owns these bytes and ` +
+            `${claim.rewriteImage ? 'its rewriteImage hook cannot represent this edit' : 'registered no rewriteImage hook'}`, fields);
+    }
+    return bytes;
+}
+/** Only the optional keys the node holds, so a rebuild adds no field the source lacked and
+ *  repeated resizes leave the alt text unchanged. */
+export function imageFieldsFromInline(image) {
+    return {
+        alt: image.alt ?? '',
+        url: image.url ?? '',
+        ...(image.title !== undefined ? { title: image.title } : {}),
+        ...(image.width !== undefined ? { width: image.width } : {}),
+        ...(image.height !== undefined ? { height: image.height } : {}),
+        ...(image.crop !== undefined ? { crop: image.crop } : {}),
+        ...(image.label !== undefined ? { label: image.label } : {})
+    };
+}
+export function sameImageFields(a, b) {
+    return (a.alt === b.alt &&
+        a.url === b.url &&
+        a.title === b.title &&
+        a.width === b.width &&
+        a.height === b.height &&
+        a.label === b.label &&
+        a.crop?.x === b.crop?.x &&
+        a.crop?.y === b.crop?.y &&
+        a.crop?.z === b.crop?.z);
+}
+// ── The GFM serializer ──────────────────────────────────────────────────────
+/** The inverse of the built-in grammar; call `buildImageEditBytes`, which decides whether the
+ *  bytes are GFM's to write. */
+export function buildImageSourceBytes(fields) {
+    const dimSuffix = buildDimSuffix(fields.width, fields.height, fields.crop);
+    const altSegment = escapeAlt(fields.alt) + dimSuffix;
+    // A reference image's url and title belong to its link reference definition.
+    if (fields.label !== undefined) {
+        return `![${altSegment}][${fields.label}]`;
+    }
+    const titleSegment = fields.title !== undefined ? ` "${escapeTitle(fields.title)}"` : '';
+    return `![${altSegment}](${encodeDestination(fields.url)}${titleSegment})`;
+}
+// Alt text keeps the label's bytes as written: a bare bracket is escaped so it can't end the
+// label, and an existing backslash pair passes through so repeated commits never double it.
+function escapeAlt(alt) {
+    let out = '';
+    for (let i = 0; i < alt.length; i++) {
+        const ch = alt[i];
+        if (ch === '\\' && i + 1 < alt.length) {
+            out += ch + alt[i + 1];
+            i++;
+            continue;
+        }
+        out += ch === '[' || ch === ']' || ch === '\\' ? '\\' + ch : ch;
+    }
+    return out;
+}