@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/plugins/latex/latex-kind.js

@@ -1,57 +1,57 @@
 /**
- * Inline `$…$` math and the two display-math block forms, as source-holding leaf
- * kinds. Engine-free: the render engine is injected through the `math-renderer` seam,
- * never imported here. Recognition is gated on registration, so with no extension
- * loaded parsing stays byte-identical to bare GFM.
+ * Inline `$…$` math and the two display-math block forms, as block kinds that hold their own
+ * source. No renderer here: `math-renderer.ts` is handed one, and this file never imports one.
+ * Recognition starts only once the plugin registers, so without it parsing stays byte-identical
+ * to plain GFM.
  */
-import { caretOffsetAtPoint, createScanIndex, declarePluginInlineKind, declarePluginKind, registerInlineSyntax, registerInlineWidgetKind, registerBlockKind, registerBlockOpener, isInlineKindDeclared, simpleLeafClosure, matchFenceOpen, matchFenceClose, OPENER_PRIORITIES } from '../../plugin';
+import { caretOffsetAtPoint, createScanIndex, declarePluginInlineKind, declarePluginKind, registerInlineSyntax, registerInlineWidgetKind, registerBlockKind, registerBlockOpener, simpleLeafClosure, fenceAnatomy, fenceRawWrite, fenceShapeOfRaw, matchFenceInfo, scanFence, OPENER_PRIORITIES, trimTrailingLineEnding, displayLines, joinDisplayLines, ownTrailingLineEnding, trailingLineEnding, trimWhitespace } from '../../plugin';
 import MathInline from './MathInline.svelte';
+import { isFlankingSpace } from './flanking';
 import { registerMathBlockCompleter } from './math-completion';
 export const MATH_INLINE = 'math';
 export const MATH_BLOCK = 'mathBlock';
 export const MATH_FENCE = 'mathFence';
 // ── Recognition ──────────────────────────────────────────────────────────────
-const isWhitespace = (ch) => /\s/.test(ch);
 const isDigit = (ch) => ch >= '0' && ch <= '9';
-function indexMathClosers(raw) {
+function indexDollars(raw) {
     const positions = [];
     for (let i = 1; i < raw.length; i++) {
-        if (raw[i] === '$' && !isWhitespace(raw[i - 1]))
+        if (raw[i] === '$')
             positions.push(i);
     }
     return Int32Array.from(positions);
 }
 // Indexed once per block, not searched per consultation: a paragraph of shell prose
 // (`$HOME $PATH $USER …`) would otherwise cost a full block scan at every `$`.
-const firstCloserFrom = createScanIndex(indexMathClosers);
-/**
- * The digit guard on the opener is what keeps `$5 and $10` currency, not math. The
- * close is deliberately not digit-guarded, so `$x^2$` closes on its `2`.
- */
+const nextDollarFrom = createScanIndex(indexDollars);
+/** Money, written the way prose writes it: a whole number between the delimiters. */
+const isPriceSpan = (body) => /^\d[\d.,]*$/.test(body);
+/** Pandoc's rule: a match ends at the next `$`, and a closer with a space before it or a digit
+ *  after leaves the opener literal. Added: a span that is only a number (`$5$`) stays prose. */
 function recognizeMath(raw, pos, end, kind) {
     const afterOpen = pos + 1;
     if (afterOpen >= end)
         return null;
     const opener = raw[afterOpen];
-    if (isWhitespace(opener) || isDigit(opener))
+    if (isFlankingSpace(opener))
         return null;
     // `$$` is the display fence, or the empty pair a keystroke just closed: never an inline
-    // opener, or its closer search would jump to the far end of the next formula on the line.
+    // opener, or the match would end on the second `$` of its own opener.
     if (opener === '$')
         return null;
-    // The index spans the whole block, so `end` decides the claim: a closer past the
-    // scan range leaves the `$` literal.
-    const close = firstCloserFrom(raw, pos + 2);
+    // The index spans the whole block, so `end` is what decides: a closer past the scan
+    // range leaves the `$` literal.
+    const close = nextDollarFrom(raw, pos + 2);
     if (close === -1 || close >= end)
         return null;
+    if (isFlankingSpace(raw[close - 1]) || isDigit(raw[close + 1] ?? ''))
+        return null;
+    if (isPriceSpan(raw.slice(afterOpen, close)))
+        return null;
     return { kind, start: pos, end: close + 1 };
 }
 // ── Registration ─────────────────────────────────────────────────────────────
 export function registerMathInline() {
-    // Keyed on the kind registry, not a module latch, so the platform reset that clears
-    // the inline registries also clears this guard.
-    if (isInlineKindDeclared(MATH_INLINE))
-        return;
     const kind = declarePluginInlineKind(MATH_INLINE);
     registerInlineSyntax('$', (raw, pos, end) => recognizeMath(raw, pos, end, kind), {
         autoPair: true
@@ -61,34 +61,90 @@ export function registerMathInline() {
         component: MathInline,
         editing: {
             revealSource: true,
-            // `$…$`: one delimiter each side, so a revealing click seats the caret on the last
-            // character of the formula rather than past its closing `$`.
-            revealContentSpan: (source) => source.length >= 2 ? { start: 1, end: source.length - 1 } : null
+            revealContentSpan: mathContentSpan,
+            revealOffsetAtPoint: mathInlineOffsetAtPoint
         }
     });
 }
+// ── Caret from a click ───────────────────────────────────────────────────────
+// KaTeX paints glyphs, not source bytes, so both forms read a click the same way: how far along
+// the painted run it landed, scaled into the span that run renders.
+/** `$…$`: one delimiter each side, so an edit stays inside the formula. */
+const mathContentSpan = (source) => source.length >= 2 ? { start: 1, end: source.length - 1 } : null;
+function glyphOffsetInSpan(rendered, span, clientX, clientY) {
+    // `.katex-html` is the half that is painted: the MathML copy beside it is clipped to a
+    // pixel, and measuring both together answers for a point nobody clicked.
+    const glyphs = rendered.querySelector('.katex-html');
+    const along = glyphs ? caretOffsetAtPoint(glyphs, clientX, clientY) : null;
+    const total = glyphs?.textContent?.length ?? 0;
+    if (along === null || total === 0)
+        return null;
+    return span.start + Math.round((along / total) * (span.end - span.start));
+}
+function mathInlineOffsetAtPoint(widgetEl, source, clientX, clientY) {
+    const span = mathContentSpan(source);
+    return span ? glyphOffsetInSpan(widgetEl, span, clientX, clientY) : null;
+}
+/** Where a click on the rendered equation puts the caret; the fence lines paint no glyphs of
+ *  their own, so a point the glyphs cannot answer for goes to the body's end. */
+function mathCaretAtPoint(blockEl, clientX, clientY) {
+    const render = blockEl.querySelector('.math-block-render');
+    if (!render)
+        return null;
+    const start = Number(render.dataset.bodyStart);
+    const end = Number(render.dataset.bodyEnd);
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return null;
+    return { path: [], offset: glyphOffsetInSpan(render, { start, end }, clientX, clientY) ?? end };
+}
 // ── Rendered display source ────────────────────────────────────────────────────
 /**
  * Shared by the render component so `mathBlock` and `mathFence` display identically.
  * Round-trip stays byte-level on `raw`, so this never feeds serialization.
  */
 export function mathDisplaySource(source) {
-    if (/^[ \t]*(?:`{3,}|~{3,})/.test(source)) {
-        const firstBreak = source.indexOf('\n');
-        if (firstBreak === -1)
-            return '';
-        const body = source
-            .slice(firstBreak + 1)
-            .replace(/(?:\r?\n)?[ \t]*(?:`{3,}|~{3,})[ \t]*\r?\n?$/, '');
-        return body.trim();
-    }
+    const fence = fenceAnatomy(source);
+    if (fence)
+        return trimWhitespace(source.slice(fence.bodyStart, fence.closerStart));
     let inner = source;
     if (inner.startsWith('$$'))
         inner = inner.slice(2);
     if (inner.endsWith('$$'))
         inner = inner.slice(0, -2);
-    return inner.trim();
+    return trimWhitespace(inner);
 }
+// ── Writing a block's own bytes ────────────────────────────────────────────────
+/** The ending a restored closer line takes: the block's own, else the document's. */
+const closerEnding = (ctx) => trailingLineEnding(ctx.node.raw, ctx.lineEnding);
+/** The `$$` kind's write rule: put back a closer a truncating write dropped, as a fenced code
+ *  block does; a first line that does not open the block is left alone. */
+function normalizeMathBlockRaw(raw, ctx) {
+    const display = trimTrailingLineEnding(raw);
+    const lines = displayLines(display);
+    const { text } = lines[0];
+    if (!text.startsWith(BLOCK_FENCE))
+        return raw;
+    if (text === BLOCK_FENCE) {
+        if (lines.slice(1).some((line) => line.text === BLOCK_FENCE))
+            return raw;
+        return display + closerEnding(ctx) + BLOCK_FENCE + ownTrailingLineEnding(raw);
+    }
+    if (isBlockMathOpener(text))
+        return raw;
+    // The one-line form closes on line 0, so the lines a join brought along stay their own blocks.
+    lines[0] = { ...lines[0], text: text + BLOCK_FENCE };
+    return joinDisplayLines(lines) + ownTrailingLineEnding(raw);
+}
+const mathBlockWrite = {
+    normalize: normalizeMathBlockRaw,
+    // A restored closer line goes after every written byte; only the one-line form's closer lands
+    // mid-write, at the end of line 0.
+    mapOffset: (raw, offset) => {
+        const { text } = displayLines(raw)[0];
+        const closesLineZero = text.startsWith(BLOCK_FENCE) && text !== BLOCK_FENCE && !isBlockMathOpener(text);
+        return closesLineZero && offset > text.length ? offset + BLOCK_FENCE.length : offset;
+    }
+};
 // ── Block `$$…$$` display math ─────────────────────────────────────────────────
 const BLOCK_FENCE = '$$';
 /** The length ≥ 4 test keeps the open/close pair disjoint; anything else `$$`-prefixed
@@ -102,17 +158,21 @@ function isBlockMathOpener(text) {
 }
 export function registerMathBlock() {
     const mathBlock = declarePluginKind(MATH_BLOCK);
-    // A source-holding leaf like `fencedCode`: `serialize` re-emits `leadingTrivia + raw`,
-    // so a raw built from the exact fence bytes round-trips byte-for-byte.
+    // A block that holds its own source, like `fencedCode`: `serialize` re-emits
+    // `leadingTrivia + raw`, so a raw built from the exact fence bytes round-trips byte for byte.
     registerBlockKind(mathBlock, {
+        label: 'Math block',
+        // A formula's source makes a poor label on the drag ghost.
+        dragLabel: 'Equation',
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
-        // The revealed source takes Enter as a literal newline and never splits, so neither
-        // edge can grow a sibling.
+        // The open source takes Enter as a literal newline and never splits, so neither edge
+        // can grow a neighbouring block.
         gapEdges: 'both',
         conformanceFixture: '$$\nx^2\n$$\n',
         caretTargetAtPoint: mathCaretAtPoint,
+        rawWrite: mathBlockWrite,
         closure: simpleLeafClosure({
             focus: {
                 mode: 'implemented',
@@ -134,7 +194,7 @@ export function registerMathBlock() {
         })
     });
     registerBlockOpener(mathBlock, {
-        // `$$` collides with no built-in matcher, so this slot is only tie avoidance.
+        // `$$` collides with no built-in matcher, so this number only keeps it from tying.
         priority: OPENER_PRIORITIES.fencedCode + 5,
         interruptsParagraph: isBlockMathOpener,
         tryOpen(ctx) {
@@ -164,46 +224,24 @@ export function registerMathBlock() {
     });
     // The open/close pair needs its lines adjacent, which Enter alone can never type.
     registerMathBlockCompleter(mathBlock);
-    // Co-registered so one install teaches both forms (the admonition/githubAlert precedent).
+    // Registered together so one install adds both forms, as admonitions and alerts do.
     registerMathFence();
 }
-/** Where a press on the folded equation puts the caret. KaTeX paints glyphs, not source bytes,
- *  so the press walks the body span in proportion to how far along the equation it fell; the
- *  fence lines carry no glyph of their own. */
-function mathCaretAtPoint(blockEl, clientX, clientY) {
-    const render = blockEl.querySelector('.math-block-render');
-    if (!render)
-        return null;
-    const start = Number(render.dataset.bodyStart);
-    const end = Number(render.dataset.bodyEnd);
-    if (!Number.isFinite(start) || !Number.isFinite(end))
-        return null;
-    // `.katex-html` is the painted half: its MathML twin is clipped to a pixel, and the pair
-    // measured together answers for a point no reader aimed at.
-    const glyphs = render.querySelector('.katex-html');
-    const along = glyphs ? caretOffsetAtPoint(glyphs, clientX, clientY) : null;
-    const total = glyphs?.textContent?.length ?? 0;
-    if (along === null || total === 0)
-        return { path: [], offset: end };
-    return { path: [], offset: start + Math.round((along / total) * (end - start)) };
-}
 // ── Fenced ```math display math ─────────────────────────────────────────────────
-// GitHub's third math form: a source-holding leaf like the `$$` block, rendered by
+// GitHub's third math form: a block holding its own source, like the `$$` block, rendered by
 // the same component.
-const FENCE_INFO_TOKEN = 'math';
-function matchMathFence(text) {
-    const fence = matchFenceOpen(text);
-    return fence && fence.info.split(/\s+/)[0] === FENCE_INFO_TOKEN ? fence : null;
-}
+const matchMathFence = matchFenceInfo('math');
 export function registerMathFence() {
     const mathFence = declarePluginKind(MATH_FENCE);
     registerBlockKind(mathFence, {
+        label: 'Math block',
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
         gapEdges: 'both',
         caretTargetAtPoint: mathCaretAtPoint,
         conformanceFixture: '```math\nx^2\n```\n',
+        rawWrite: fenceRawWrite(fenceShapeOfRaw),
         closure: simpleLeafClosure({
             focus: {
                 mode: 'implemented',
@@ -227,31 +265,21 @@ export function registerMathFence() {
         })
     });
     registerBlockOpener(mathFence, {
-        // `fencedCode` accepts every fence, ```math included, so this must price ahead of
-        // that superset matcher, in its own slot below the sibling mermaid.
+        // `fencedCode` accepts every fence, ```math included, so this has to be tried before
+        // it, at a priority of its own just below mermaid's.
         priority: OPENER_PRIORITIES.fencedCode - 4,
         interruptsParagraph: (line) => matchMathFence(line) !== null,
         tryOpen(ctx) {
             const fence = matchMathFence(ctx.line.text);
             if (!fence)
                 return null;
-            let closeIdx = -1;
-            for (let i = ctx.index + 1; i < ctx.end; i++) {
-                if (matchFenceClose(ctx.lines[i].text, fence.marker, fence.length)) {
-                    closeIdx = i;
-                    break;
-                }
-            }
-            // Unterminated declines so the built-in fencedCode claims it as a plain
-            // `math` code block, matching the sibling `$$` block.
-            if (closeIdx === -1)
+            const scan = scanFence(ctx, fence);
+            // An unterminated fence backs out, so the built-in fencedCode takes it as a plain
+            // `math` code block, matching the `$$` block.
+            if (scan.closer === -1)
                 return null;
-            const raw = ctx.lines
-                .slice(ctx.index, closeIdx + 1)
-                .map((l) => l.raw)
-                .join('');
-            const node = { kind: mathFence, leadingTrivia: ctx.leadingTrivia, raw };
-            return { node, consumed: closeIdx + 1 - ctx.index };
+            const node = { kind: mathFence, leadingTrivia: ctx.leadingTrivia, raw: scan.raw };
+            return { node, consumed: scan.consumed };
         }
     });
 }

package/dist/plugins/latex/math-completion.d.ts

@@ -5,6 +5,6 @@
  */
 import { type AnyBlockKind, type CompletionResult } from '../../plugin';
 /** Exactly the fence and nothing else: `$$x$$` is already a whole block and `$$ x` opens no
- *  multi-line form, so neither is a gesture toward the pair this completes. */
+ *  multi-line form, so neither is an attempt at the pair this completes. */
 export declare function tryCompleteMathBlock(line: string): CompletionResult | null;
 export declare function registerMathBlockCompleter(kind: AnyBlockKind): void;

package/dist/plugins/latex/math-completion.js

@@ -3,20 +3,17 @@
  * the closer, with the caret on the body. Registered beside the kind, so with no extension loaded
  * `$$` plus Enter still splits exactly as bare GFM does.
  */
-import { isBlockCompleterRegistered, registerBlockCompleter } from '../../plugin';
+import { registerBlockCompleter, trimWhitespace } from '../../plugin';
 const BLOCK_FENCE = '$$';
 /** Exactly the fence and nothing else: `$$x$$` is already a whole block and `$$ x` opens no
- *  multi-line form, so neither is a gesture toward the pair this completes. */
+ *  multi-line form, so neither is an attempt at the pair this completes. */
 export function tryCompleteMathBlock(line) {
-    if (line.trim() !== BLOCK_FENCE)
+    if (trimWhitespace(line) !== BLOCK_FENCE)
         return null;
     return { lines: [BLOCK_FENCE, '', BLOCK_FENCE], caret: { path: [], line: 1, column: 0 } };
 }
 export function registerMathBlockCompleter(kind) {
-    if (isBlockCompleterRegistered(kind))
-        return;
-    // On type as well as at Enter: a lone `$$` can only be the pair's opener, so the block forms
-    // as the second `$` lands — the way a typed ` ``` ` is a fence at once — with the caret on
-    // the body line. The one-line `$$x$$` form is still reachable by typing into that body.
+    // On typing as well as on Enter: a lone `$$` can only be the pair's opener, so the block
+    // forms as the second `$` is typed, the way a typed ` ``` ` becomes a fence at once.
     registerBlockCompleter(kind, { tryComplete: tryCompleteMathBlock, onType: true });
 }

package/dist/plugins/latex/math-layout.d.ts

@@ -1,15 +1,9 @@
 /**
  * How a `$$` block lays out its source and preview while it is being edited. `split` (side by
  * side) is the default because it moves the page least; `stacked` suits long equations; `source`
- * shows no preview. A host picks the default through `latexPlugin({ blockLayout })`, and the
- * block's own toggle still cycles from there.
+ * shows no preview. A host picks the default through `latexPlugin({ blockLayout })` or an
+ * editor's `{ plugin, options }` entry, and the block's own toggle cycles from there.
  */
 export type MathBlockLayout = 'split' | 'stacked' | 'source';
 export declare const MATH_BLOCK_LAYOUTS: readonly MathBlockLayout[];
 export declare function isMathBlockLayout(value: unknown): value is MathBlockLayout;
-/**
- * The starting layout: this editor's per-instance plugin options first (`{ plugin, options:
- * { blockLayout } }`), then the factory's own default (`latexPlugin({ blockLayout })`), then
- * `split`. An unknown value falls through rather than throwing.
- */
-export declare function resolveDefaultLayout(options: unknown, fallback?: MathBlockLayout): MathBlockLayout;

package/dist/plugins/latex/math-layout.js

@@ -2,12 +2,3 @@ export const MATH_BLOCK_LAYOUTS = ['split', 'stacked', 'source'];
 export function isMathBlockLayout(value) {
     return MATH_BLOCK_LAYOUTS.includes(value);
 }
-/**
- * The starting layout: this editor's per-instance plugin options first (`{ plugin, options:
- * { blockLayout } }`), then the factory's own default (`latexPlugin({ blockLayout })`), then
- * `split`. An unknown value falls through rather than throwing.
- */
-export function resolveDefaultLayout(options, fallback = 'split') {
-    const declared = options?.blockLayout;
-    return isMathBlockLayout(declared) ? declared : fallback;
-}

package/dist/plugins/latex/math-renderer.d.ts

@@ -1,26 +1,23 @@
 /**
- * The renderer-adapter seam: `latexPlugin({ renderer })` injects the engine here at
- * install, so the plugin core never imports one. Widgets and leaves read the active
- * renderer through this module because their frozen props carry no renderer channel,
- * and the one document-wide memo means a repeated formula renders once.
+ * Where the math renderer is plugged in: `latexPlugin({ renderer })` sets it at install time, so
+ * the plugin's own code never imports KaTeX. Blocks and widgets render through `mathSlot`
+ * because their props carry no renderer; one cache for the whole document means a repeated
+ * formula renders once per theme.
  */
+/** `theme` is for an adapter that draws its own colors; one written against `{ display }` alone
+ *  stays assignable. */
 export type MathRenderer = (source: string, opts: {
     display: boolean;
-}) => {
+    theme: string;
+}) => MathRender;
+export interface MathRender {
     dom: HTMLElement;
     error?: string;
-};
-/**
- * Memoizes the render work, not the node: `cloneOnRead` is what lets `inner` run once
- * per key while each caller still gets its own detached node to mount.
- */
-export declare function createMemoizedRenderer(inner: MathRenderer): MathRenderer;
-export declare function setMathRenderer(renderer: MathRenderer): void;
-export declare function renderInlineMath(source: string): {
-    dom: HTMLElement;
-    error?: string;
-};
-export declare function renderDisplayMath(source: string): {
-    dom: HTMLElement;
-    error?: string;
-};
+}
+export declare const mathSlot: import("../../plugin").RendererSlot<{
+    source: string;
+    display: boolean;
+}, MathRender>;
+/** A formula the renderer rejected: its typed source in the error color, with the parser's
+ *  message on hover. */
+export declare function mathErrorNode(source: string, message: string): HTMLElement;

package/dist/plugins/latex/math-renderer.js

@@ -1,42 +1,25 @@
 /**
- * The renderer-adapter seam: `latexPlugin({ renderer })` injects the engine here at
- * install, so the plugin core never imports one. Widgets and leaves read the active
- * renderer through this module because their frozen props carry no renderer channel,
- * and the one document-wide memo means a repeated formula renders once.
+ * Where the math renderer is plugged in: `latexPlugin({ renderer })` sets it at install time, so
+ * the plugin's own code never imports KaTeX. Blocks and widgets render through `mathSlot`
+ * because their props carry no renderer; one cache for the whole document means a repeated
+ * formula renders once per theme.
  */
-import { createBoundedMemo } from '../../plugin';
-// ── Memoized wrapper ──────────────────────────────────────────────────────────
-const MEMO_CAP = 256;
-/**
- * Memoizes the render work, not the node: `cloneOnRead` is what lets `inner` run once
- * per key while each caller still gets its own detached node to mount.
- */
-export function createMemoizedRenderer(inner) {
-    const memo = createBoundedMemo({
-        cap: MEMO_CAP,
-        cloneOnRead: (entry) => ({ dom: entry.dom.cloneNode(true), error: entry.error })
-    });
-    return (source, opts) => memo(`${source}\x00${opts.display}`, () => inner(source, opts));
-}
-// ── Injection seam ──────────────────────────────────────────────────────────────
-// Deliberately no default engine: the core must not import one, and the plugin's
-// required `renderer` option guarantees this is set before any widget mounts.
-let activeRenderer = null;
-export function setMathRenderer(renderer) {
-    activeRenderer = createMemoizedRenderer(renderer);
-}
-export function renderInlineMath(source) {
-    return render(source, false);
-}
-export function renderDisplayMath(source) {
-    return render(source, true);
-}
-function render(source, display) {
-    if (!activeRenderer) {
-        const dom = document.createElement('span');
-        dom.className = 'math-error';
-        dom.textContent = 'Math error: renderer not configured';
-        return { dom, error: 'renderer not configured' };
+import { createRendererSlot, renderSourceFallback } from '../../plugin';
+export const mathSlot = createRendererSlot({
+    key: ({ source, display }) => `${display}\0${source}`,
+    // A cached node can sit in one place only, so every caller mounts its own copy.
+    cloneOnRead: ({ dom, error }) => ({ dom: dom.cloneNode(true), error }),
+    missing: ({ source }) => ({ dom: renderSourceFallback(source, 'Math renderer not configured') }),
+    failed: ({ source }, error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        return { dom: mathErrorNode(source, message), error: message };
     }
-    return activeRenderer(source, { display });
+});
+/** A formula the renderer rejected: its typed source in the error color, with the parser's
+ *  message on hover. */
+export function mathErrorNode(source, message) {
+    const dom = renderSourceFallback(source, message);
+    dom.className = 'math-error';
+    dom.style.color = 'var(--color-error, #d03025)';
+    return dom;
 }

package/dist/plugins/latex/math-source.d.ts

@@ -1,17 +1,13 @@
 /**
- * Where the body sits inside the block's source. The fence lines carry no glyph of their own, so
- * a point measured against the rendered equation names a place in this span and nowhere else.
+ * Where the body sits inside the block's source. The fence lines paint no glyphs of their own,
+ * so a point measured against the rendered equation can only name a place inside this span.
  */
 export declare function mathBodySpan(text: string): {
     start: number;
     end: number;
 };
-/**
- * A `$$` block with no body LINE — `$$$$`, `$$\n$$`, a whitespace-only one-liner — has nowhere
- * for a caret to sit once the fence lines hide, and Backspace has no byte it could mean. The
- * completion every such block takes as its source is revealed: opener, one empty body line,
- * closer, caret on that line. A block that already has a body line, blank or not, is left alone.
- */
+/** A block with no body line (`$$$$`, `$$\n$$`) has no caret position once the fence lines hide,
+ *  so it gains one empty body line with the caret on it. */
 export declare function completeBareMathSource(text: string): {
     text: string;
     caret: number;