@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -1,17 +1,17 @@
 /**
- * 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 indexDollars(raw) {
     const positions = [];
@@ -26,28 +26,25 @@ function indexDollars(raw) {
 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, with one divergence of ours. An attempt ENDS at the next `$`, whichever it is,
- * and a bad closer leaves the opener literal; a closer needs a non-space before it and no digit
- * after it. Ours: a span that is only a number is a price (`$5$`), so a typed price stays prose.
- */
+/** 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))
+    if (isFlankingSpace(opener))
         return null;
     // `$$` is the display fence, or the empty pair a keystroke just closed: never an inline
-    // opener, or the attempt would end on its own twin.
+    // 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.
+    // 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 (isWhitespace(raw[close - 1]) || isDigit(raw[close + 1] ?? ''))
+    if (isFlankingSpace(raw[close - 1]) || isDigit(raw[close + 1] ?? ''))
         return null;
     if (isPriceSpan(raw.slice(afterOpen, close)))
         return null;
@@ -55,10 +52,6 @@ function recognizeMath(raw, pos, end, kind) {
 }
 // ── 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
@@ -73,14 +66,14 @@ export function registerMathInline() {
         }
     });
 }
-// ── Caret from a press ───────────────────────────────────────────────────────
-// KaTeX paints glyphs, not source bytes, so both forms read a press the same way: how far along
-// the painted run it fell, walked proportionally into the span the run renders.
+// ── 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 painted half: its MathML twin is clipped to a pixel, and the pair
-    // measured together answers for a point no reader aimed at.
+    // `.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;
@@ -92,8 +85,8 @@ function mathInlineOffsetAtPoint(widgetEl, source, clientX, clientY) {
     const span = mathContentSpan(source);
     return span ? glyphOffsetInSpan(widgetEl, span, clientX, clientY) : null;
 }
-/** Where a press on the folded equation puts the caret; the fence lines carry no glyph of
- *  their own, so a point the glyphs cannot answer for keeps the body's end. */
+/** 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)
@@ -110,22 +103,48 @@ function mathCaretAtPoint(blockEl, clientX, clientY) {
  * 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
@@ -139,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',
@@ -171,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) {
@@ -201,26 +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();
 }
 // ── 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',
@@ -244,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 ```math straight over its closer — 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: opener, one empty body line, closer, caret on that line,
- * rebuilt from its OWN delimiters. A block that 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;

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

@@ -1,103 +1,58 @@
 /**
- * The block form's source as DOM, shaped like a code block's: each fence line in a
- * `.md-fence-line` wrapper the marker-hiding modes collapse, the body as LaTeX highlight
- * tokens. Text-preserving by construction — opener + body + closer is the input — so the
- * offset walk and G1.28 hold. Anything not shaped like a fence paints as plain tokens.
+ * The block form's source as DOM, drawn the way a code block draws its own: the fence lines as
+ * markers the marker-hiding modes collapse, the body as highlighted LaTeX tokens. It emits exactly
+ * the source's text, so the DOM-to-offset traversal stays exact (G1.28). Anything not shaped like
+ * a fence paints as plain tokens.
  */
-import { highlightCode, matchFenceClose, matchFenceOpen } from '../../plugin';
+import { displayLines, fenceBodyAsDrawn, highlightCode, isBlankText, renderFencedSource, sliceFencedSource } from '../../plugin';
 const FENCE = '$$';
 const unsliced = (text) => ({ opener: '', body: text, closer: '' });
-/** Both block forms are an opener line, a body and a closer line; only the closer test differs,
- *  since GitHub's ```math carries its info string on the opener and closes on a bare fence. */
+/** Both block forms are an opener line, a body and a closer line. GitHub's ```math reads as a code
+ *  fence does; the `$$` form closes on a line that is exactly `$$`, or on line 0 itself. */
 function sliceMathSource(text) {
-    const firstNewline = text.indexOf('\n');
-    if (text.startsWith(FENCE)) {
-        // One-line form: `$$x^2$$`.
-        if (firstNewline === -1) {
-            return text.length >= 4 && text.endsWith(FENCE)
-                ? { opener: FENCE, body: text.slice(2, -2), closer: FENCE }
-                : unsliced(text);
-        }
-        if (text.slice(0, firstNewline) !== FENCE)
-            return unsliced(text);
-        return sliceFenceLines(text, firstNewline, (line) => line === FENCE);
+    if (!text.startsWith(FENCE))
+        return sliceFencedSource(text) ?? unsliced(text);
+    const firstBreak = text.indexOf('\n');
+    if (firstBreak === -1) {
+        return text.length >= 4 && text.endsWith(FENCE)
+            ? { opener: FENCE, body: text.slice(2, -2), closer: FENCE }
+            : unsliced(text);
     }
-    if (firstNewline === -1)
+    if (displayLines(text)[0].text !== FENCE)
         return unsliced(text);
-    // CommonMark's fence rules stay the editor's: a closer repeats its opener's own marker, at
-    // that length or longer.
-    const fence = matchFenceOpen(text.slice(0, firstNewline));
-    if (!fence)
-        return unsliced(text);
-    return sliceFenceLines(text, firstNewline, (line) => matchFenceClose(line, fence.marker, fence.length));
-}
-function sliceFenceLines(text, firstNewline, isCloser) {
-    const opener = text.slice(0, firstNewline + 1);
+    const opener = text.slice(0, firstBreak + 1);
     const rest = text.slice(opener.length);
-    const lastNewline = rest.lastIndexOf('\n');
-    const lastLine = lastNewline === -1 ? rest : rest.slice(lastNewline + 1);
-    if (!isCloser(lastLine))
+    const lastBreak = rest.lastIndexOf('\n');
+    const lastLine = rest.slice(lastBreak + 1);
+    if (lastLine !== FENCE)
         return { opener, body: rest, closer: '' };
-    if (lastNewline === -1)
-        return { opener, body: '', closer: lastLine };
-    // The newline before the closer belongs to the closer's line (the code block's rule), so
-    // collapsing that line leaves no blank line at the box's edge — unless the body is blank,
-    // where that newline IS the one line the caret can sit on.
-    const bodyWithEnding = rest.slice(0, lastNewline + 1);
-    if (!/\S/.test(bodyWithEnding))
-        return { opener, body: bodyWithEnding, closer: lastLine };
-    return { opener, body: rest.slice(0, lastNewline), closer: rest.slice(lastNewline) };
-}
-function fenceLine(text) {
-    const line = document.createElement('span');
-    line.className = 'md-fence-line';
-    const marker = document.createElement('span');
-    marker.className = 'md-marker md-fence';
-    marker.textContent = text.replace(/\n$/, '').replace(/^\n/, '');
-    if (text.startsWith('\n'))
-        line.appendChild(document.createTextNode('\n'));
-    line.appendChild(marker);
-    if (text.endsWith('\n'))
-        line.appendChild(document.createTextNode('\n'));
-    return line;
+    return { opener, body: rest.slice(0, lastBreak + 1), closer: lastLine };
 }
 /**
- * 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 function mathBodySpan(text) {
-    const { opener, body } = sliceMathSource(text);
-    return { start: opener.length, end: opener.length + body.length };
+    const source = sliceMathSource(text);
+    const start = source.opener.length;
+    return { start, end: start + fenceBodyAsDrawn(source).length };
 }
-/**
- * A block with no body LINE — `$$$$`, `$$\n$$`, a ```math straight over its closer — 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: opener, one empty body line, closer, caret on that line,
- * rebuilt from its OWN delimiters. A block that 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 function completeBareMathSource(text) {
     const { opener, body, closer } = sliceMathSource(text);
     if (!opener || !closer)
         return null;
-    if (body.includes('\n') || body.trim() !== '')
+    if (body.includes('\n') || !isBlankText(body))
         return null;
-    const openerLine = opener.replace(/\n$/, '');
-    return { text: `${openerLine}\n\n${closer}`, caret: openerLine.length + 1 };
+    // A one-line `$$$$` has no ending of its own to repeat.
+    const [openerLine] = displayLines(opener);
+    const ending = openerLine.ending || '\n';
+    return {
+        text: openerLine.text + ending + ending + closer,
+        caret: openerLine.text.length + ending.length
+    };
 }
 export function renderMathSource(text) {
-    const { opener, body, closer } = sliceMathSource(text);
-    const frag = document.createDocumentFragment();
-    if (opener)
-        frag.appendChild(fenceLine(opener));
-    frag.appendChild(highlightCode(body, 'latex'));
-    // An empty last body line has only the hidden closer after it; the anchor gives the caret
-    // that line (see `code-renderer.ts`).
-    if (closer.startsWith('\n') && body.endsWith('\n')) {
-        const anchor = document.createElement('br');
-        anchor.dataset.caretAnchor = 'closer';
-        frag.appendChild(anchor);
-    }
-    if (closer)
-        frag.appendChild(fenceLine(closer));
-    return frag;
+    return renderFencedSource(sliceMathSource(text), (body) => highlightCode(body, 'latex'));
 }