@voithos-labs/aragonite 0.10.1

package/dist/plugins/highlight-occurrences/index.d.ts

@@ -0,0 +1 @@
+export { highlightOccurrencesPlugin, type HighlightOccurrencesOptions } from './highlight-occurrences-plugin';

package/dist/plugins/highlight-occurrences/index.js

@@ -0,0 +1 @@
+export { highlightOccurrencesPlugin } from './highlight-occurrences-plugin';

package/dist/plugins/highlight-occurrences/occurrence-source.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The plugin-guide § Decorations "memoize the scan on editEpoch" recipe: the index costs a
+ * document walk, so it is rebuilt only when the epoch bumps, carrying each leaf's token list
+ * across the rebuild, and a caret move re-filters the cached index with one map read.
+ * The marks step aside while you type: an epoch arriving under a caret with no `edit` event
+ * ahead of it is a keystroke, and any edit event puts them back.
+ */
+import type { DecorationSource, EditorSelection } from '../../plugin';
+export interface OccurrenceSourceDeps {
+    /** Fires on each real index rebuild, carrying how many leaves that rebuild had to
+     *  tokenize: the seam a memoization test asserts against. */
+    onScan?: (stats: {
+        tokenizedLeaves: number;
+    }) => void;
+}
+export interface OccurrenceSource {
+    readonly source: DecorationSource;
+    setSelection(selection: EditorSelection | null): void;
+    /**
+     * Report an `edit` op. Any of them ends the hold; only `input`, the batched flush that
+     * ends a typing burst, leaves the next epoch readable as another keystroke. Returns
+     * whether the caller must invalidate to reveal marks the hold was keeping back.
+     */
+    noteEdit(op: string): boolean;
+}
+export declare function createOccurrenceSource(deps?: OccurrenceSourceDeps): OccurrenceSource;

package/dist/plugins/highlight-occurrences/occurrence-source.js

@@ -0,0 +1,54 @@
+/**
+ * The plugin-guide § Decorations "memoize the scan on editEpoch" recipe: the index costs a
+ * document walk, so it is rebuilt only when the epoch bumps, carrying each leaf's token list
+ * across the rebuild, and a caret move re-filters the cached index with one map read.
+ * The marks step aside while you type: an epoch arriving under a caret with no `edit` event
+ * ahead of it is a keystroke, and any edit event puts them back.
+ */
+import { anchorWord, buildOccurrenceIndex } from './occurrences';
+const SOURCE_NAME = 'highlight-occurrences';
+export function createOccurrenceSource(deps = {}) {
+    let selection = null;
+    let index = new Map();
+    let tokens = new Map();
+    // Sentinel below any real epoch, so the first provide always scans.
+    let indexedEpoch = -1;
+    let typing = false;
+    // Nothing can have been typed into a source that has not run yet, so the first epoch it
+    // ever sees is a document arrival however the caret sits.
+    let structuralSinceScan = true;
+    function provide(doc, { editEpoch }) {
+        if (editEpoch !== indexedEpoch) {
+            indexedEpoch = editEpoch;
+            const scan = buildOccurrenceIndex(doc, tokens);
+            index = scan.index;
+            tokens = scan.tokens;
+            deps.onScan?.({ tokenizedLeaves: scan.tokenizedLeaves });
+            // A keystroke lands under a caret and says nothing on the edit channel until its
+            // burst flushes. An epoch missing either mark is some other document change: a
+            // commit that already announced itself, or a whole-document swap, which drops
+            // the caret before its epoch arrives.
+            typing = !structuralSinceScan && selection !== null;
+            structuralSinceScan = false;
+        }
+        if (typing)
+            return [];
+        const word = anchorWord(doc, selection);
+        return word ? (index.get(word) ?? []) : [];
+    }
+    return {
+        source: { name: SOURCE_NAME, provide },
+        setSelection(next) {
+            selection = next;
+        },
+        noteEdit(op) {
+            // Undo bumps the content version before it emits, so a structural op can reach
+            // here AFTER the epoch it moved: ending the hold here covers both orders.
+            if (op !== 'input')
+                structuralSinceScan = true;
+            const held = typing;
+            typing = false;
+            return held;
+        }
+    };
+}

package/dist/plugins/highlight-occurrences/occurrences.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure occurrence scan: indexing by word is what turns the caret-driven lookup into
+ * one map read rather than a fresh document walk. Offsets are per-leaf raw offsets,
+ * dimmed markers included, the space mark decorations consume. `isProseKind` gates the
+ * scope, so a code/HTML/raw leaf is neither scanned nor a valid anchor.
+ */
+import { type DocumentView, type EditorSelection, type MarkDecoration } from '../../plugin';
+export declare const OCCURRENCE_CLASS = "hl-occurrence";
+export interface WordSpan {
+    word: string;
+    start: number;
+    end: number;
+}
+export type OccurrenceIndex = Map<string, MarkDecoration[]>;
+/** Token lists keyed by the leaf `raw` they were scanned from, so a leaf whose bytes did
+ *  not move costs one string compare instead of a re-tokenize. */
+export type TokenCache = Map<string, WordSpan[]>;
+export interface OccurrenceScan {
+    index: OccurrenceIndex;
+    /** Carry into the next scan; a leaf gone from the document drops out of it. */
+    tokens: TokenCache;
+    /** Leaves whose text had to be tokenized, the seam a memoization test asserts on. */
+    tokenizedLeaves: number;
+}
+/** Prefers the char at the caret, falling back to the one before it (the usual
+ *  word-under-caret rule). */
+export declare function wordAt(text: string, offset: number): WordSpan | null;
+/** Null when the focus is not a leaf (a container/cell-coordinate endpoint) or the
+ *  caret sits on a non-word char. */
+export declare function anchorWord(doc: DocumentView, selection: EditorSelection | null): string | null;
+/** Built once per document change by a memoizing source, not once per caret move. The
+ *  marks are rebuilt every time (they carry paths), the tokens only for changed leaves. */
+export declare function buildOccurrenceIndex(doc: DocumentView, cached?: TokenCache): OccurrenceScan;

package/dist/plugins/highlight-occurrences/occurrences.js

@@ -0,0 +1,108 @@
+/**
+ * Pure occurrence scan: indexing by word is what turns the caret-driven lookup into
+ * one map read rather than a fresh document walk. Offsets are per-leaf raw offsets,
+ * dimmed markers included, the space mark decorations consume. `isProseKind` gates the
+ * scope, so a code/HTML/raw leaf is neither scanned nor a valid anchor.
+ */
+import { isProseKind } from '../../plugin';
+export const OCCURRENCE_CLASS = 'hl-occurrence';
+// Astral-plane text falls outside "word" here, which is honest enough for a reference plugin.
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+/** Prefers the char at the caret, falling back to the one before it (the usual
+ *  word-under-caret rule). */
+export function wordAt(text, offset) {
+    if (offset < 0 || offset > text.length)
+        return null;
+    let anchor = -1;
+    if (offset < text.length && WORD_CHAR.test(text[offset]))
+        anchor = offset;
+    else if (offset > 0 && WORD_CHAR.test(text[offset - 1]))
+        anchor = offset - 1;
+    if (anchor < 0)
+        return null;
+    let start = anchor;
+    while (start > 0 && WORD_CHAR.test(text[start - 1]))
+        start--;
+    let end = anchor + 1;
+    while (end < text.length && WORD_CHAR.test(text[end]))
+        end++;
+    return { word: text.slice(start, end), start, end };
+}
+/** Null when the focus is not a leaf (a container/cell-coordinate endpoint) or the
+ *  caret sits on a non-word char. */
+export function anchorWord(doc, selection) {
+    if (!selection)
+        return null;
+    const leaf = leafAt(doc, selection.focus.path);
+    if (!leaf || !isProseKind(leaf.kind))
+        return null;
+    const span = wordAt(leaf.raw, selection.focus.offset);
+    return span ? span.word : null;
+}
+/** Built once per document change by a memoizing source, not once per caret move. The
+ *  marks are rebuilt every time (they carry paths), the tokens only for changed leaves. */
+export function buildOccurrenceIndex(doc, cached) {
+    const index = new Map();
+    const tokens = new Map();
+    let tokenizedLeaves = 0;
+    forEachLeaf(doc.children, [], (node, path) => {
+        if (!isProseKind(node.kind))
+            return;
+        let spans = tokens.get(node.raw) ?? cached?.get(node.raw);
+        if (!spans) {
+            spans = [...tokenizeWords(node.raw)];
+            tokenizedLeaves++;
+        }
+        tokens.set(node.raw, spans);
+        for (const span of spans) {
+            const mark = {
+                type: 'mark',
+                path,
+                start: span.start,
+                end: span.end,
+                class: OCCURRENCE_CLASS
+            };
+            const bucket = index.get(span.word);
+            if (bucket)
+                bucket.push(mark);
+            else
+                index.set(span.word, [mark]);
+        }
+    });
+    return { index, tokens, tokenizedLeaves };
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+function leafAt(doc, path) {
+    let children = doc.children;
+    let node = null;
+    for (const index of path) {
+        node = children?.[index] ?? null;
+        if (!node)
+            return null;
+        children = node.children;
+    }
+    return node && !node.children ? node : null;
+}
+function forEachLeaf(children, path, visit) {
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        const childPath = [...path, i];
+        if (node.children)
+            forEachLeaf(node.children, childPath, visit);
+        else
+            visit(node, childPath);
+    }
+}
+function* tokenizeWords(text) {
+    let i = 0;
+    while (i < text.length) {
+        if (!WORD_CHAR.test(text[i])) {
+            i++;
+            continue;
+        }
+        const start = i;
+        while (i < text.length && WORD_CHAR.test(text[i]))
+            i++;
+        yield { word: text.slice(start, i), start, end: i };
+    }
+}

package/dist/plugins/latex/BlockMath.svelte

@@ -0,0 +1,119 @@
+<script module lang="ts">
+	// Mount id plus render count are the A2 acceptance oracle: editing one equation must
+	// leave every untouched block's pair unchanged.
+	let nextMountId = 0;
+</script>
+
+<script lang="ts">
+	// 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';
+	import { renderDisplayMath } from './math-renderer';
+	import { mathDisplaySource } from './latex-kind';
+
+	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
+
+	// eslint-disable-next-line no-useless-assignment -- <script module> counter read by the next instance mount
+	const mountId = nextMountId++;
+	let renderCount = 0;
+
+	let sourceEl: HTMLDivElement | undefined = $state();
+	let renderEl: HTMLDivElement | undefined = $state();
+	let revealed = $state(false);
+
+	const leaf = createEditableLeaf({
+		getNode: () => node,
+		getIndex: () => index,
+		getPath: () => myPath,
+		getEl: () => sourceEl ?? null,
+		mode: 'render-primary',
+		isRevealed: () => revealed,
+		setRevealed: (value) => {
+			revealed = value;
+		}
+	});
+
+	// ── 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);
+		renderCount += 1;
+		renderEl.dataset.renderCount = String(renderCount);
+	});
+
+	// ── BlockComponent interface ────────────────────────────────────────────────
+
+	export const editable = true;
+	export const focusable = true;
+
+	export const focus = leaf.focus;
+	export const parkCaret = leaf.parkCaret;
+	export const focusAtColumn = leaf.focusAtColumn;
+	export const getCursorOffset = leaf.getCursorOffset;
+	export const getSelectedText = leaf.getSelectedText;
+	export const setSelection = leaf.setSelection;
+	export const measurePartialRects = leaf.measurePartialRects;
+	export const runCommand = leaf.runCommand;
+	export const insertMarkdown = leaf.insertMarkdown;
+
+	void ({
+		editable,
+		focusable,
+		focus,
+		parkCaret,
+		focusAtColumn,
+		getCursorOffset,
+		getSelectedText,
+		setSelection,
+		measurePartialRects,
+		runCommand,
+		insertMarkdown
+	} 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}
+
+<style>
+	/* Deltas over the shared .md-source-surface (editor.css). */
+	.math-block-source {
+		outline: none;
+		padding: 12px;
+		white-space: pre;
+		overflow-x: auto;
+		overflow-y: hidden;
+	}
+
+	.math-block-render {
+		display: block;
+		padding: 8px 12px;
+		text-align: center;
+		cursor: text;
+		border: 1px solid transparent;
+		border-radius: 4px;
+		overflow-x: auto;
+	}
+
+	.math-block-render:hover {
+		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
+	}
+</style>

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

@@ -0,0 +1,21 @@
+import { type NodeView } from '../../plugin';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    myPath?: number[];
+};
+declare const BlockMath: import("svelte").Component<$$ComponentProps, {
+    editable: true;
+    focusable: true;
+    focus: (offset: number) => void;
+    parkCaret: (offset: number) => void;
+    focusAtColumn: (x: number, from: import("../../plugin").StickyColumnDirection) => void;
+    getCursorOffset: () => number | null;
+    getSelectedText: () => string;
+    setSelection: (start: number, end: number) => void;
+    measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
+    runCommand: (id: import("../../plugin").CommandId) => boolean;
+    insertMarkdown: (md: string) => boolean;
+}, "">;
+type BlockMath = ReturnType<typeof BlockMath>;
+export default BlockMath;

package/dist/plugins/latex/MathInline.svelte

@@ -0,0 +1,28 @@
+<script module lang="ts">
+	// The pool reuses an instance while its source is unchanged, so this id is what the
+	// e2e keys on: stable across neighbouring keystrokes, new after a source edit.
+	let nextMountId = 0;
+</script>
+
+<script lang="ts">
+	import type { InlineWidgetComponentProps } from '../../plugin';
+	import { renderInlineMath } from './math-renderer';
+
+	// Frozen at mount on purpose: the pool remounts on any source change, so the
+	// `$`-stripped interior can never go stale under the instance.
+	let { source }: InlineWidgetComponentProps = $props();
+	// svelte-ignore state_referenced_locally
+	const inner = source.slice(1, -1);
+	// eslint-disable-next-line no-useless-assignment -- <script module> counter read by the next instance mount
+	const mountId = nextMountId++;
+
+	let el: HTMLSpanElement;
+
+	// Inside a client $effect, so SSR renders no widget DOM; the frozen interior means
+	// it runs once per instance.
+	$effect(() => {
+		el.replaceChildren(renderInlineMath(inner).dom);
+	});
+</script>
+
+<span bind:this={el} class="math-inline-widget" data-mount-id={mountId}></span>

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

@@ -0,0 +1,4 @@
+import type { InlineWidgetComponentProps } from '../../plugin';
+declare const MathInline: import("svelte").Component<InlineWidgetComponentProps, {}, "">;
+type MathInline = ReturnType<typeof MathInline>;
+export default MathInline;

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

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

package/dist/plugins/latex/index.js

@@ -0,0 +1,4 @@
+// `MathRenderer` is re-exported type-only so a host can name it without pulling katex;
+// the adapter itself lives at the `/renderer` subpath.
+export { latexPlugin } from './register';
+export { MATH_INLINE, MATH_BLOCK, MATH_FENCE } from './latex-kind';

package/dist/plugins/latex/latex-kind.d.ts

@@ -0,0 +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.
+ */
+export declare const MATH_INLINE = "math";
+export declare const MATH_BLOCK = "mathBlock";
+export declare const MATH_FENCE = "mathFence";
+export declare function registerMathInline(): void;
+/**
+ * Shared by the render component so `mathBlock` and `mathFence` display identically.
+ * Round-trip stays byte-level on `raw`, so this never feeds serialization.
+ */
+export declare function mathDisplaySource(source: string): string;
+export declare function registerMathBlock(): void;
+export declare function registerMathFence(): void;

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

@@ -0,0 +1,224 @@
+/**
+ * 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.
+ */
+import { 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';
+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) {
+    const positions = [];
+    for (let i = 1; i < raw.length; i++) {
+        if (raw[i] === '$' && !isWhitespace(raw[i - 1]))
+            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`.
+ */
+function recognizeMath(raw, pos, end, kind) {
+    const afterOpen = pos + 1;
+    if (afterOpen >= end)
+        return null;
+    const opener = raw[afterOpen];
+    if (isWhitespace(opener) || isDigit(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);
+    if (close === -1 || close >= end)
+        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));
+    registerInlineWidgetKind(kind, {
+        isWidget: () => true,
+        component: MathInline,
+        editing: { revealSource: true }
+    });
+}
+// ── 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();
+    }
+    let inner = source;
+    if (inner.startsWith('$$'))
+        inner = inner.slice(2);
+    if (inner.endsWith('$$'))
+        inner = inner.slice(0, -2);
+    return inner.trim();
+}
+// ── Block `$$…$$` display math ─────────────────────────────────────────────────
+const BLOCK_FENCE = '$$';
+/** The length ≥ 4 test keeps the open/close pair disjoint; anything else `$$`-prefixed
+ *  (`$$ x` with no same-line close) is not an opener and falls to a paragraph. */
+function isBlockMathOpener(text) {
+    if (!text.startsWith(BLOCK_FENCE))
+        return false;
+    if (text.length >= 4 && text.endsWith(BLOCK_FENCE))
+        return true;
+    return text === BLOCK_FENCE;
+}
+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.
+    registerBlockKind(mathBlock, {
+        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.
+        gapEdges: 'both',
+        conformanceFixture: '$$\nx^2\n$$\n',
+        closure: simpleLeafClosure({
+            focus: {
+                mode: 'implemented',
+                via: 'createEditableLeaf render-primary reveal (source ⇄ rendered)'
+            },
+            selectionPaint: {
+                mode: 'implemented',
+                via: 'measurePartialRects (raw offsets) while the source is revealed'
+            },
+            searchPaint: {
+                mode: 'implemented',
+                via: 'source raw scanned and navigable; while folded, createEditableLeaf covers the rendered block box (opaque single-unit fallback)'
+            },
+            undo: {
+                mode: 'implemented',
+                via: 'render-primary — the reveal→edit→blur cycle commits as one undo entry'
+            },
+            simOracle: { mode: 'implemented', via: 'block-math editable-leaf e2e' }
+        })
+    });
+    registerBlockOpener(mathBlock, {
+        // `$$` collides with no built-in matcher, so this slot is only tie avoidance.
+        priority: OPENER_PRIORITIES.fencedCode + 5,
+        interruptsParagraph: isBlockMathOpener,
+        tryOpen(ctx) {
+            const text = ctx.line.text;
+            if (!text.startsWith(BLOCK_FENCE))
+                return null;
+            if (text.length >= 4 && text.endsWith(BLOCK_FENCE)) {
+                return {
+                    node: { kind: mathBlock, leadingTrivia: ctx.leadingTrivia, raw: ctx.line.raw },
+                    consumed: 1
+                };
+            }
+            if (text !== BLOCK_FENCE)
+                return null;
+            let i = ctx.index + 1;
+            while (i < ctx.end && ctx.lines[i].text !== BLOCK_FENCE)
+                i++;
+            if (i >= ctx.end)
+                return null; // unterminated fence declines to paragraph
+            const raw = ctx.lines
+                .slice(ctx.index, i + 1)
+                .map((l) => l.raw)
+                .join('');
+            const node = { kind: mathBlock, leadingTrivia: ctx.leadingTrivia, raw };
+            return { node, consumed: i + 1 - ctx.index };
+        }
+    });
+    // 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).
+    registerMathFence();
+}
+// ── Fenced ```math display math ─────────────────────────────────────────────────
+// GitHub's third math form: a source-holding leaf 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;
+}
+export function registerMathFence() {
+    const mathFence = declarePluginKind(MATH_FENCE);
+    registerBlockKind(mathFence, {
+        mergeRole: 'not-mergeable',
+        editable: true,
+        supportsInline: false,
+        gapEdges: 'both',
+        conformanceFixture: '```math\nx^2\n```\n',
+        closure: simpleLeafClosure({
+            focus: {
+                mode: 'implemented',
+                via: 'createEditableLeaf render-primary reveal (source ⇄ rendered)'
+            },
+            selectionPaint: {
+                mode: 'implemented',
+                via: 'measurePartialRects (raw offsets) while the source is revealed'
+            },
+            searchPaint: {
+                mode: 'implemented',
+                via: 'source raw scanned and navigable; while folded, createEditableLeaf covers the rendered block box (opaque single-unit fallback)'
+            },
+            undo: {
+                mode: 'implemented',
+                via: 'render-primary reveal→edit→blur cycle commits as one undo entry'
+            },
+            // No note-taking simulation drives a ```math fence; its interactive path is pinned
+            // by the plugins e2e battery instead.
+            simOracle: { mode: 'inherit-default' }
+        })
+    });
+    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.
+        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)
+                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 };
+        }
+    });
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Block math's Enter completer: a lone `$$` line completes into the open fence, an empty body and
+ * 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 { 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. */
+export declare function tryCompleteMathBlock(line: string): CompletionResult | null;
+export declare function registerMathBlockCompleter(kind: AnyBlockKind): void;