@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/plugins/latex/BlockMath.svelte

@@ -8,10 +8,32 @@
 	// Render-primary editable leaf: all editing behavior lives in `createEditableLeaf`,
 	// so this component owns only the render↔source swap visuals.
 	import { createEditableLeaf, type BlockComponent, type NodeView } from '../../plugin';
+	// Plugin-local like the other labels here: bundled plugins import only the public barrel.
+	// The three ways the source and its preview can share the block while editing (see
+	// `math-layout.ts`); the host's plugin options pick the starting one. The toggle cycles
+	// them and names the NEXT layout.
+	type MathLayout = MathBlockLayout;
+	const LAYOUT_NEXT: Record<MathLayout, MathLayout> = {
+		split: 'stacked',
+		stacked: 'source',
+		source: 'split'
+	};
+	const LAYOUT_TITLE: Record<MathLayout, string> = {
+		split: 'Preview beside the source',
+		stacked: 'Preview below the source',
+		source: 'Source only'
+	};
 	import { renderDisplayMath } from './math-renderer';
 	import { mathDisplaySource } from './latex-kind';
+	import { completeBareMathSource, mathBodySpan, renderMathSource } from './math-source';
+	import { resolveDefaultLayout, type MathBlockLayout } from './math-layout';
 
-	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
+	let {
+		node,
+		index,
+		myPath = [],
+		blockLayout = 'split'
+	}: { node: NodeView; index: number; myPath?: number[]; blockLayout?: MathBlockLayout } = $props();
 
 	// eslint-disable-next-line no-useless-assignment -- <script module> counter read by the next instance mount
 	const mountId = nextMountId++;
@@ -20,6 +42,9 @@
 	let sourceEl: HTMLDivElement | undefined = $state();
 	let renderEl: HTMLDivElement | undefined = $state();
 	let revealed = $state(false);
+	// The in-flight source while revealed: a render-primary edit reaches the CST only on blur,
+	// so the live preview reads the surface, not the node. Null when nothing is in flight.
+	let draft = $state<string | null>(null);
 
 	const leaf = createEditableLeaf({
 		getNode: () => node,
@@ -30,16 +55,58 @@
 		isRevealed: () => revealed,
 		setRevealed: (value) => {
 			revealed = value;
+			draft = null;
+		},
+		renderSource: renderMathSource,
+		completeBareSource: completeBareMathSource,
+		onSourceEdit: (text) => {
+			draft = text;
 		}
 	});
 
+	// While editing, the preview is a sibling of the surface that holds focus: its scrollbar (a
+	// wide equation overflows the half-width card) must not take that focus, since losing it is
+	// what folds the editor. Same device as the eye button; a fold click is a click while folded.
+	function keepSourceFocus(e: MouseEvent): void {
+		if (revealed) e.preventDefault();
+	}
+
+	// Per-instance and per-session: a reader who changes the layout is asking about THIS equation
+	// while they edit it, not setting a preference for the document. The starting layout is the
+	// host's: this editor's plugin options, else the factory's default.
+	// svelte-ignore state_referenced_locally
+	let layout = $state<MathLayout>(resolveDefaultLayout(leaf.getOptions(), blockLayout));
+	const previewOpen = $derived(layout !== 'source');
+
+	// The edits the leaf applies itself report through `onSourceEdit`; this is the native path
+	// (a composition's commit), where the highlight goes stale until repainted. The leaf's own
+	// handler runs first so the IME bookkeeping it owns is untouched.
+	function onSourceInput(e: Event): void {
+		leaf.surfaceProps.oninput();
+		if ((e as InputEvent).isComposing) return;
+		leaf.repaintSource();
+		draft = sourceEl?.textContent ?? null;
+	}
+
 	// ── View rendering ──────────────────────────────────────────────────────────
 
 	// Re-runs on every remount of the render div and on any source change; the
 	// document-wide memo clones a cached node, so a repeat formula is cheap.
 	$effect(() => {
-		if (revealed || !renderEl) return;
-		renderEl.replaceChildren(renderDisplayMath(mathDisplaySource(leaf.sourceText)).dom);
+		if (!renderEl) return;
+		// Runs while REVEALED as well: the split keeps a live preview beside the source, so the
+		// equation re-renders as it is typed rather than only when the source folds away.
+		const text = draft ?? leaf.sourceText;
+		const source = mathDisplaySource(text);
+		renderEl.replaceChildren(renderDisplayMath(source).dom);
+		// The span a press on the glyphs lands in: the descriptor's `caretTargetAtPoint` reads the
+		// rendered element alone and has no other way to the bytes behind it.
+		const body = mathBodySpan(text);
+		renderEl.dataset.bodyStart = String(body.start);
+		renderEl.dataset.bodyEnd = String(body.end);
+		// An equation with nothing in it renders nothing, which folded would be an invisible block
+		// the user cannot find to delete; it keeps the card's fill instead, like an empty fence.
+		renderEl.toggleAttribute('data-empty', source.trim() === '');
 		renderCount += 1;
 		renderEl.dataset.renderCount = String(renderCount);
 	});
@@ -74,46 +141,214 @@
 	} satisfies BlockComponent);
 </script>
 
-{#if revealed}
-	<div
-		bind:this={sourceEl}
-		{...leaf.surfaceProps}
-		class="math-block-source md-source-surface"
-		aria-label="Math source"
-	></div>
-{:else}
-	<div
-		bind:this={renderEl}
-		class="math-block-render"
-		data-mount-id={mountId}
-		role="button"
-		tabindex="-1"
-		aria-label="Math (click to edit)"
-		{...leaf.renderProps}
-	></div>
-{/if}
+<!-- Editing shows source AND render side by side rather than swapping one for the other: the
+	swap re-flowed the whole document on every click, and a preview that only appears after you
+	stop editing is the one you needed while typing. Each half is a card, and the eye sits in the
+	top-right of whichever card is showing. -->
+<div
+	class="math-block"
+	class:math-block-editing={revealed}
+	class:math-block-split={revealed && layout === 'split'}
+	class:math-block-stacked={revealed && layout === 'stacked'}
+>
+	{#if revealed}
+		<div class="math-block-card">
+			<div
+				bind:this={sourceEl}
+				{...leaf.surfaceProps}
+				oninput={onSourceInput}
+				class="math-block-source md-source-surface"
+				aria-label="Math source"
+			></div>
+			<!-- The toggle keeps one seat: the top-right card. Side by side that is the preview; stacked
+				and source-only it is this card. -->
+			{#if layout !== 'split'}
+				{@render layoutToggle()}
+			{/if}
+		</div>
+	{/if}
+	{#if !revealed || previewOpen}
+		<div class="math-block-card">
+			<div
+				bind:this={renderEl}
+				class="math-block-render"
+				data-mount-id={mountId}
+				role="button"
+				tabindex="-1"
+				aria-label="Math (click to edit)"
+				{...leaf.renderProps}
+				onmousedown={keepSourceFocus}
+			></div>
+			{#if revealed && layout === 'split'}
+				{@render layoutToggle()}
+			{/if}
+		</div>
+	{/if}
+</div>
+
+{#snippet layoutToggle()}
+	{@const next = LAYOUT_NEXT[layout]}
+	<button
+		type="button"
+		class="math-preview-toggle"
+		aria-label={LAYOUT_TITLE[next]}
+		title={LAYOUT_TITLE[next]}
+		onmousedown={(e) => e.preventDefault()}
+		onclick={() => (layout = next)}
+	>
+		<svg
+			viewBox="0 0 24 24"
+			width="13"
+			height="13"
+			fill="none"
+			stroke="currentColor"
+			stroke-width="1.75"
+			stroke-linecap="round"
+			stroke-linejoin="round"
+			aria-hidden="true"
+		>
+			{#if layout === 'split'}
+				<rect width="18" height="18" x="3" y="3" rx="2" /><path d="M12 3v18" />
+			{:else if layout === 'stacked'}
+				<rect width="18" height="18" x="3" y="3" rx="2" /><path d="M3 12h18" />
+			{:else}
+				<path
+					d="M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49"
+				/><path d="M14.084 14.158a3 3 0 0 1-4.242-4.242" /><path
+					d="M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143"
+				/><path d="m2 2 20 20" />
+			{/if}
+		</svg>
+	</button>
+{/snippet}
 
 <style>
-	/* Deltas over the shared .md-source-surface (editor.css). */
+	/* At rest the render alone, laid out as a plain block so it centres exactly as it did
+	   before any of this existed. Editing turns the block into two equal cards. */
+	.math-block-split {
+		display: grid;
+		grid-template-columns: 1fr 1fr;
+		align-items: stretch;
+		gap: 6px;
+	}
+
+	/* Stacked: the source over its preview, each the block's full width — for the equation too
+	   long to read at half width. Not the default: it grows the block and reshuffles the page. */
+	.math-block-stacked {
+		display: grid;
+		grid-template-columns: 1fr;
+		gap: 6px;
+	}
+
+	/* The equation's cards are boxes like a code block's, and take the same stand-off from their
+	   neighbours (editor.css, fencedCode). Padding, not margin: the height model measures the
+	   host's box. */
+	:global(.block-host[data-block-kind='mathBlock']) {
+		padding-block: 6px;
+	}
+
+	/* Each half is its own card, and the containing block for its eye. */
+	.math-block-card {
+		position: relative;
+		min-width: 0;
+		border-radius: 8px;
+	}
+
+	/* Keyed on EDITING, not on the split: folding the preview away leaves one card, and a card
+	   that lost its fill the moment it stood alone would read as having left edit mode. */
+	.math-block-editing .math-block-card {
+		display: flex;
+		align-items: center;
+		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
+	}
+
+	/* Deltas over the shared .md-source-surface (editor.css) — including its accent border,
+	   which announced a state the card's own fill already carries. */
 	.math-block-source {
 		outline: none;
-		padding: 12px;
-		white-space: pre;
-		overflow-x: auto;
-		overflow-y: hidden;
+		padding: 10px 12px;
+		/* WRAP, rather than scroll sideways. The card is half the block's width, so any real
+		   formula overflows it, and a horizontal scrollbar hides the very text being edited.
+		   `pre-wrap` keeps the author's own line breaks and wraps only what is too long;
+		   LaTeX carries no indentation structure for wrapping to destroy. */
+		white-space: pre-wrap;
+		overflow-wrap: anywhere;
+		/* LEFT, like every other source surface. Centring gave each line a different starting
+		   x, which is exactly what makes multi-line LaTeX unreadable; the RENDER is the half
+		   that is genuinely centred, and the pairing is what Overleaf and friends do. */
+		text-align: left;
+		background: transparent;
+		border-color: transparent;
+		border-radius: 8px;
+	}
+
+	/* The card stretches the source so its box fills the column; without it a short formula's
+	   surface shrink-wraps and the caret only lands where the text is. */
+	.math-block-editing .math-block-card > .math-block-source {
+		flex: 1;
+		min-width: 0;
 	}
 
 	.math-block-render {
 		display: block;
-		padding: 8px 12px;
+		width: 100%;
+		padding: 10px 12px;
 		text-align: center;
 		cursor: text;
 		border: 1px solid transparent;
-		border-radius: 4px;
+		border-radius: 8px;
 		overflow-x: auto;
 	}
 
-	.math-block-render:hover {
+	/* Folded and empty: the fill stays, so there is a box to see and click into. */
+	.math-block:not(.math-block-editing) .math-block-render[data-empty] {
 		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
+		/* The editing card's height exactly — one source line at its size, plus its padding and
+		   hairline — so folding and unfolding an empty equation moves nothing. */
+		min-height: calc(0.9em * 1.5 + 22px);
+		box-sizing: border-box;
+	}
+
+	/* At rest the render is the whole block and a hover tint is its only affordance; inside a
+	   card the fill is already there, so the tint would double it. */
+	.math-block:not(.math-block-editing) .math-block-render:hover {
+		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
+	}
+
+	.math-preview-toggle {
+		position: absolute;
+		top: 4px;
+		right: 4px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 22px;
+		height: 22px;
+		padding: 0;
+		border: none;
+		border-radius: 5px;
+		background: transparent;
+		color: var(--color-ui-muted, #8f8f89);
+		cursor: pointer;
+		opacity: 0;
+		transition: opacity 120ms ease-out;
+	}
+
+	/* Transient like every other affordance here: the pointer over the block, or the eye itself
+	   holding focus. */
+	.math-block:hover .math-preview-toggle,
+	.math-preview-toggle:focus-visible {
+		opacity: 1;
+	}
+
+	.math-preview-toggle:hover {
+		background: var(--color-ui-faint, rgba(255, 255, 255, 0.07));
+		color: var(--color-text-secondary, #cfcfca);
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.math-preview-toggle {
+			transition: none;
+		}
 	}
 </style>

package/dist/plugins/latex/BlockMath.svelte.d.ts

@@ -1,8 +1,10 @@
 import { type NodeView } from '../../plugin';
+import { type MathBlockLayout } from './math-layout';
 type $$ComponentProps = {
     node: NodeView;
     index: number;
     myPath?: number[];
+    blockLayout?: MathBlockLayout;
 };
 declare const BlockMath: import("svelte").Component<$$ComponentProps, {
     editable: true;

package/dist/plugins/latex/index.d.ts

@@ -1,3 +1,4 @@
-export { latexPlugin } from './register';
+export { latexPlugin, type LatexPluginOptions } from './register';
 export { MATH_INLINE, MATH_BLOCK, MATH_FENCE } from './latex-kind';
 export type { MathRenderer } from './math-renderer';
+export type { MathBlockLayout } from './math-layout';

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

@@ -4,7 +4,7 @@
  * never imported here. Recognition is gated on registration, so with no extension
  * loaded parsing stays byte-identical to bare GFM.
  */
-import { createScanIndex, declarePluginInlineKind, declarePluginKind, registerInlineSyntax, registerInlineWidgetKind, registerBlockKind, registerBlockOpener, isInlineKindDeclared, simpleLeafClosure, matchFenceOpen, matchFenceClose, OPENER_PRIORITIES } from '../../plugin';
+import { caretOffsetAtPoint, createScanIndex, declarePluginInlineKind, declarePluginKind, registerInlineSyntax, registerInlineWidgetKind, registerBlockKind, registerBlockOpener, isInlineKindDeclared, simpleLeafClosure, matchFenceOpen, matchFenceClose, OPENER_PRIORITIES } from '../../plugin';
 import MathInline from './MathInline.svelte';
 import { registerMathBlockCompleter } from './math-completion';
 export const MATH_INLINE = 'math';
@@ -13,33 +13,44 @@ 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);
+const nextDollarFrom = createScanIndex(indexDollars);
+/** Money, written the way prose writes it: a whole number between the delimiters. */
+const isPriceSpan = (body) => /^\d[\d.,]*$/.test(body);
 /**
- * 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`.
+ * 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.
  */
 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 (isWhitespace(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.
+    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);
+    const close = nextDollarFrom(raw, pos + 2);
     if (close === -1 || close >= end)
         return null;
+    if (isWhitespace(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 ─────────────────────────────────────────────────────────────
@@ -49,13 +60,50 @@ export function registerMathInline() {
     if (isInlineKindDeclared(MATH_INLINE))
         return;
     const kind = declarePluginInlineKind(MATH_INLINE);
-    registerInlineSyntax('$', (raw, pos, end) => recognizeMath(raw, pos, end, kind));
+    registerInlineSyntax('$', (raw, pos, end) => recognizeMath(raw, pos, end, kind), {
+        autoPair: true
+    });
     registerInlineWidgetKind(kind, {
         isWidget: () => true,
         component: MathInline,
-        editing: { revealSource: true }
+        editing: {
+            revealSource: true,
+            revealContentSpan: mathContentSpan,
+            revealOffsetAtPoint: mathInlineOffsetAtPoint
+        }
     });
 }
+// ── 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.
+/** `$…$`: 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.
+    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 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. */
+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.
@@ -101,6 +149,7 @@ export function registerMathBlock() {
         // edge can grow a sibling.
         gapEdges: 'both',
         conformanceFixture: '$$\nx^2\n$$\n',
+        caretTargetAtPoint: mathCaretAtPoint,
         closure: simpleLeafClosure({
             focus: {
                 mode: 'implemented',
@@ -170,6 +219,7 @@ export function registerMathFence() {
         editable: true,
         supportsInline: false,
         gapEdges: 'both',
+        caretTargetAtPoint: mathCaretAtPoint,
         conformanceFixture: '```math\nx^2\n```\n',
         closure: simpleLeafClosure({
             focus: {

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

@@ -15,5 +15,8 @@ export function tryCompleteMathBlock(line) {
 export function registerMathBlockCompleter(kind) {
     if (isBlockCompleterRegistered(kind))
         return;
-    registerBlockCompleter(kind, { tryComplete: tryCompleteMathBlock });
+    // 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.
+    registerBlockCompleter(kind, { tryComplete: tryCompleteMathBlock, onType: true });
 }

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

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+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

@@ -0,0 +1,13 @@
+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-source.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+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.
+ */
+export declare function completeBareMathSource(text: string): {
+    text: string;
+    caret: number;
+} | null;
+export declare function renderMathSource(text: string): DocumentFragment;

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

@@ -0,0 +1,103 @@
+/**
+ * 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.
+ */
+import { highlightCode, matchFenceClose, matchFenceOpen } 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. */
+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 (firstNewline === -1)
+        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 rest = text.slice(opener.length);
+    const lastNewline = rest.lastIndexOf('\n');
+    const lastLine = lastNewline === -1 ? rest : rest.slice(lastNewline + 1);
+    if (!isCloser(lastLine))
+        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;
+}
+/**
+ * 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.
+ */
+export function mathBodySpan(text) {
+    const { opener, body } = sliceMathSource(text);
+    return { start: opener.length, end: opener.length + body.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.
+ */
+export function completeBareMathSource(text) {
+    const { opener, body, closer } = sliceMathSource(text);
+    if (!opener || !closer)
+        return null;
+    if (body.includes('\n') || body.trim() !== '')
+        return null;
+    const openerLine = opener.replace(/\n$/, '');
+    return { text: `${openerLine}\n\n${closer}`, caret: openerLine.length + 1 };
+}
+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;
+}