@voithos-labs/aragonite 0.10.3 → 0.10.4

package/dist/cursor/visual-lines.js

@@ -1,8 +1,9 @@
 /**
- * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets
- * alone can't answer it past 2 wrapped lines, so cursor Y is compared to the first/last
- * line's Y. The text-node walk works around collapsed ranges next to non-text children
- * (dimmed marker spans) returning null rects — measuring around real text always works.
+ * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets alone
+ * can't answer it past 2 wrapped lines, so the cursor's line is compared to the edge line's.
+ * Collapsed ranges beside non-text children (dimmed markers, atomic islands) measure to nothing,
+ * so the edge line is measured around real text, and a rect-less caret reads the box it sits
+ * against.
  */
 import { domDescendants } from './dom-walk';
 import { FALLBACK_LINE_HEIGHT } from './typography-estimates';
@@ -61,6 +62,7 @@ export function findLastTextNode(root) {
 export function isAtFirstVisualLine(el, fallbackOffset, contentStart) {
     return isAtEdgeVisualLine(el, () => fallbackOffset <= contentStart, {
         isEmpty: (el.textContent ?? '').length === 0,
+        toStart: true,
         boundaryTop: () => {
             const firstText = findFirstTextNode(el);
             const top = firstText ? getCharRangeTop(firstText, 0, false) : null;
@@ -71,6 +73,7 @@ export function isAtFirstVisualLine(el, fallbackOffset, contentStart) {
 export function isAtLastVisualLine(el, fallbackOffset, contentEnd) {
     return isAtEdgeVisualLine(el, () => fallbackOffset >= contentEnd, {
         isEmpty: contentEnd === 0,
+        toStart: false,
         boundaryTop: () => {
             const lastText = findLastTextNode(el);
             const top = lastText ? getCharRangeTop(lastText, lastText.textContent.length, true) : null;
@@ -80,7 +83,7 @@ export function isAtLastVisualLine(el, fallbackOffset, contentEnd) {
 }
 // ── Internal ────────────────────────────────────────────────────────────────
 /** The shared skeleton of the two edge predicates: `fallback` answers where geometry cannot — a
- *  dropped range, an unmeasurable collapsed caret, an unmeasurable boundary line — and
+ *  dropped range, a caret no box can be found for, an unmeasurable boundary line — and
  *  `boundaryTop` measures the edge line each side's own way. */
 function isAtEdgeVisualLine(el, fallback, edge) {
     const sel = window.getSelection();
@@ -89,19 +92,61 @@ function isAtEdgeVisualLine(el, fallback, edge) {
     if (edge.isEmpty)
         return true;
     const cursorRange = sel.getRangeAt(0);
+    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || FALLBACK_LINE_HEIGHT;
+    const tolerance = lineHeight * SAME_LINE_TOLERANCE;
     const cursorTop = getRangeTop(cursorRange);
-    if (cursorTop === null)
-        return cursorRange.collapsed ? fallback() : true;
+    if (cursorTop === null) {
+        if (!cursorRange.collapsed)
+            return true;
+        // A caret beside an atomic island sits at an element-level position and measures to no rect
+        // of its own: it rides the island's box, and is at the edge line when nothing reaches past.
+        const band = neighbourBand(cursorRange);
+        const contents = bandOfRange(contentsRange(el));
+        if (!band || !contents)
+            return fallback();
+        return edge.toStart
+            ? band.top < contents.top + tolerance
+            : band.bottom > contents.bottom - tolerance;
+    }
     const edgeTop = edge.boundaryTop();
     if (edgeTop === null)
         return fallback();
-    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || FALLBACK_LINE_HEIGHT;
-    return Math.abs(cursorTop - edgeTop) < lineHeight * SAME_LINE_TOLERANCE;
+    return Math.abs(cursorTop - edgeTop) < tolerance;
 }
-/** The boundary line's collapsed-contents fallback measurement. */
-function collapsedContentsTop(el, toStart) {
+/** The vertical band of the box a rect-less caret sits against: the child it precedes, else the
+ *  one it follows. Null where the caret is not at an element-level position. */
+function neighbourBand(range) {
+    const container = range.startContainer;
+    if (container.nodeType !== Node.ELEMENT_NODE)
+        return null;
+    const children = container.childNodes;
+    return (nodeBand(children[range.startOffset], false) ?? nodeBand(children[range.startOffset - 1], true));
+}
+function nodeBand(node, fromEnd) {
+    if (!node)
+        return null;
+    const range = document.createRange();
+    range.selectNode(node);
+    // A node that wraps has one rect per line, and the caret touches the line on its own side.
+    const rects = range.getClientRects();
+    if (rects.length === 0)
+        return bandOfRange(range);
+    return bandOf(rects[fromEnd ? rects.length - 1 : 0]);
+}
+function contentsRange(el) {
     const range = document.createRange();
     range.selectNodeContents(el);
+    return range;
+}
+function bandOfRange(range) {
+    return bandOf(range.getBoundingClientRect());
+}
+function bandOf(rect) {
+    return rect.height > 0 ? { top: rect.top, bottom: rect.bottom } : null;
+}
+/** The boundary line's collapsed-contents fallback measurement. */
+function collapsedContentsTop(el, toStart) {
+    const range = contentsRange(el);
     range.collapse(toStart);
     return getRangeTop(range);
 }

package/dist/cursor/widget-edge-snap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which atomic island's raw edge a point lands on: the NEAREST edge among the islands the caller
+ * measures, so a run of flush islands answers the one the point is actually beside. A point inside
+ * one reads its kind: a character-like island names the edge on the point's side, while an island
+ * that selects whole declines and keeps its own click handling.
+ */
+export interface WidgetEdgeCandidate {
+    /** The island's own raw source span; the caret seats at one end or the other. */
+    start: number;
+    end: number;
+    rect: Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>;
+    /** The kind reads as one character, so a press ON it names an edge by side rather than
+     *  selecting the island whole. */
+    seatsInside: boolean;
+}
+export interface WidgetEdgeSeat {
+    offset: number;
+    /** The press landed ON the island: the engine answers such a point with a position in the
+     *  neighbouring text, so its own caret is no reason to stand this seat down. */
+    inside: boolean;
+}
+/**
+ * The raw offset a point snaps to, in document order for ties. Null where the point snaps to none:
+ * inside an island that selects whole, whose own click handling owns it, or with no island to
+ * either side. A null `y` is a point with no line to compare against, so vertical distance drops
+ * out and horizontal containment alone reads as inside.
+ */
+export declare function nearestWidgetEdgeSeat(candidates: Iterable<WidgetEdgeCandidate>, x: number, y: number | null): WidgetEdgeSeat | null;

package/dist/cursor/widget-edge-snap.js

@@ -0,0 +1,38 @@
+/**
+ * Which atomic island's raw edge a point lands on: the NEAREST edge among the islands the caller
+ * measures, so a run of flush islands answers the one the point is actually beside. A point inside
+ * one reads its kind: a character-like island names the edge on the point's side, while an island
+ * that selects whole declines and keeps its own click handling.
+ */
+/**
+ * The raw offset a point snaps to, in document order for ties. Null where the point snaps to none:
+ * inside an island that selects whole, whose own click handling owns it, or with no island to
+ * either side. A null `y` is a point with no line to compare against, so vertical distance drops
+ * out and horizontal containment alone reads as inside.
+ */
+export function nearestWidgetEdgeSeat(candidates, x, y) {
+    let best = null;
+    for (const { start, end, rect, seatsInside } of candidates) {
+        const withinRow = y === null || (rect.top < y && y < rect.bottom);
+        if (rect.left < x && x < rect.right && withinRow) {
+            if (!seatsInside)
+                return null;
+            return { offset: x < (rect.left + rect.right) / 2 ? start : end, inside: true };
+        }
+        // Rows before columns: a point past the end of one line must not reach an island on
+        // another line that happens to sit at the same x.
+        const rowGap = y === null ? 0 : Math.max(rect.top - y, y - rect.bottom, 0);
+        if (x <= rect.left)
+            best = nearer(best, { offset: start, rowGap, gap: rect.left - x });
+        if (x >= rect.right)
+            best = nearer(best, { offset: end, rowGap, gap: x - rect.right });
+    }
+    return best === null ? null : { offset: best.offset, inside: false };
+}
+function nearer(held, next) {
+    if (!held)
+        return next;
+    if (next.rowGap !== held.rowGap)
+        return next.rowGap < held.rowGap ? next : held;
+    return next.gap < held.gap ? next : held;
+}

package/dist/cursor/widget-offset.d.ts

@@ -42,6 +42,9 @@ export declare function findDomTextOffsetTarget(container: ParentNode, target: D
  * against the ambient-adjusted argument.
  */
 export declare function widgetsIntersectingRange(container: HTMLElement, start: DomTextOffset, end: DomTextOffset): HTMLElement[];
+/** The walk's text with marker chrome and widget bytes blanked to spaces, at the walk's own
+ *  offsets: what a rule reading words (the multi-click ladder) sees as content. */
+export declare function maskedWalkText(container: ParentNode): string;
 /** Total walk length of `container` — its one-past-end walk position. */
 export declare function containerDomTextLength(container: ParentNode): DomTextOffset;
 /**

package/dist/cursor/widget-offset.js

@@ -111,6 +111,16 @@ export function widgetsIntersectingRange(container, start, end) {
     }
     return out;
 }
+/** The walk's text with marker chrome and widget bytes blanked to spaces, at the walk's own
+ *  offsets: what a rule reading words (the multi-click ladder) sees as content. */
+export function maskedWalkText(container) {
+    let out = '';
+    for (const seg of walkSegments(container, null)) {
+        const content = seg.kind === 'text' && markerRootOf(seg.node, container) === null;
+        out += content ? (seg.node.textContent ?? '') : ' '.repeat(seg.len);
+    }
+    return out;
+}
 /** Total walk length of `container` — its one-past-end walk position. */
 export function containerDomTextLength(container) {
     let count = 0;

package/dist/decorations/reserved-attrs.js

@@ -18,6 +18,7 @@ export const RESERVED_BLOCK_ATTRS = new Set([
     'data-image-widget',
     'data-inline-widget',
     'data-link-card',
+    'data-pointer-gesture',
     'data-presentation',
     'data-table-row-idx'
 ]);

package/dist/editor-actions/focus/focus-dispatch.js

@@ -3,7 +3,7 @@
  * No Svelte context or reactivity; inputs are passed in as parameters.
  */
 import { CURSOR_END, CURSOR_START } from '../../block-component';
-import { consumeStickyLanding } from './focus-landing';
+import { consumeStickyLanding, verticalArrival } from './focus-landing';
 /** Move focus within a container, or delegate upward when out of range. */
 export async function dispatchMoveFocus(refs, innerIndex, position, stickyColumn, parent, scope = {}) {
     const { childCount, options, gapStop } = scope;
@@ -89,13 +89,16 @@ export function dispatchFocusAtColumn(refs, x, from) {
     if (refs.length === 0)
         return;
     const indices = from === 'above' ? refs.map((_, i) => i) : refs.map((_, i) => refs.length - 1 - i);
-    // Skip vertically-transparent refs so an entry from above/below lands on the
-    // first/last text-bearing child, not an image-only paragraph.
+    // Pass over transparent refs so an entry from above/below lands on the first/last
+    // text-bearing child.
     for (const i of indices) {
         const ref = refs[i];
         if (!ref?.focusable)
             continue;
-        if (ref.isVerticallyTransparent?.())
+        const arrival = verticalArrival(ref, from);
+        if (arrival === 'entered')
+            return;
+        if (arrival === 'transparent')
             continue;
         if (ref.focusAtColumn)
             ref.focusAtColumn(x, from);

package/dist/editor-actions/focus/focus-landing.d.ts

@@ -2,6 +2,15 @@
  * Shared cross-block landing tail for the focus dispatchers. Sticky-X null handling
  * lives here, so `focusAtColumn` receivers always get a finite x.
  */
-import { type BlockComponent, type FocusPosition } from '../../block-component';
+import { type BlockComponent, type FocusPosition, type StickyColumnDirection } from '../../block-component';
 import type { StickyColumnState } from '../../cursor/sticky-column';
 export declare function consumeStickyLanding(block: BlockComponent, index: number, position: FocusPosition, stickyColumn: StickyColumnState, retryAt: (index: number) => Promise<void> | void): Promise<void>;
+/** What a vertical arrival does at a block: enter its widget, pass over it, or seat a caret. */
+export type VerticalArrival = 'entered' | 'transparent' | 'seat';
+/**
+ * The vertical stop rule, asked by both vertical doors: the per-block landing and a container's
+ * column entry. A widget-only block carries no column, so it is passed over unless its edge widget
+ * takes the arrival, which is a stop of its own and reads alike from either side. `'entered'` means
+ * the widget ALREADY took it, so the caller stops rather than repeating the entry.
+ */
+export declare function verticalArrival(block: BlockComponent, from: StickyColumnDirection): VerticalArrival;

package/dist/editor-actions/focus/focus-landing.js

@@ -5,12 +5,15 @@
 import { CURSOR_END, CURSOR_START } from '../../block-component';
 export async function consumeStickyLanding(block, index, position, stickyColumn, retryAt) {
     const isStickyMove = typeof position === 'object' && 'stickyColumnFrom' in position;
-    // Widget-only blocks contribute no column landing, so ArrowUp/Down passes through.
-    // Horizontal moves still stop at the widget edge.
-    if (isStickyMove && block.isVerticallyTransparent?.()) {
-        const direction = position.stickyColumnFrom === 'below' ? -1 : 1;
-        await retryAt(index + direction);
-        return;
+    if (isStickyMove) {
+        const from = position.stickyColumnFrom;
+        const arrival = verticalArrival(block, from);
+        if (arrival === 'entered')
+            return;
+        if (arrival === 'transparent') {
+            await retryAt(index + (from === 'below' ? -1 : 1));
+            return;
+        }
     }
     // Enter an edge widget rather than dropping a no-op caret at its boundary, so the
     // arrow key produces one visible step.
@@ -37,3 +40,14 @@ export async function consumeStickyLanding(block, index, position, stickyColumn,
     else
         block.focus(CURSOR_END);
 }
+/**
+ * The vertical stop rule, asked by both vertical doors: the per-block landing and a container's
+ * column entry. A widget-only block carries no column, so it is passed over unless its edge widget
+ * takes the arrival, which is a stop of its own and reads alike from either side. `'entered'` means
+ * the widget ALREADY took it, so the caller stops rather than repeating the entry.
+ */
+export function verticalArrival(block, from) {
+    if (!block.isVerticallyTransparent?.())
+        return 'seat';
+    return block.enterEdgeWidget?.(from === 'above' ? 'start' : 'end') ? 'entered' : 'transparent';
+}

package/dist/editor-actions/plugin/container.d.ts

@@ -87,6 +87,13 @@ export interface ContainerBlock {
      * entry and windowing reveal. False for a modified or non-arrow key: leave it native.
      */
     moveFocusOut(e: KeyboardEvent): boolean;
+    /**
+     * The reader's scroll position, captured now. Call before a state flip that swaps this
+     * block's view for one of a different height, then await the returned restore: the
+     * scrollport is back where it was once the swap has flushed. A reveal in flight outranks
+     * it and the restore stands down.
+     */
+    captureScrollPosition(): () => Promise<void>;
 }
 /**
  * Collapse-ness has ONE definition: the descriptor's `reservedChrome.isCollapsed`

package/dist/editor-actions/plugin/container.js

@@ -13,6 +13,7 @@ import { eventToChord } from '../../schema/keybindings';
 import { isReadingMode } from '../../presentation-mode';
 import { devWarn } from '../../dev-warn';
 import { BLOCK_EDIT_KEY, CONTAINER_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_POLICIES_KEY, EDITOR_SERVICES_KEY, FOCUS_KEY, HISTORY_KEY } from '../../editor-keys';
+import { captureScrollPosition } from '../../cursor/scroll-hold';
 import { emitCommandError } from '../../editor-events';
 import { owningPluginEditor } from '../../schema/plugin-install';
 import { createBlockListState } from '../../reactivity/block-list-state.svelte';
@@ -130,7 +131,7 @@ export function createContainerBlock(deps) {
     const parentFocus = getContext(FOCUS_KEY);
     const parentContainerEdit = getContext(CONTAINER_EDIT_KEY);
     const history = getContext(HISTORY_KEY);
-    const { stickyColumn, edgeAffinity, selection, reorder, events: editorEvents, registryView, activePlugins } = getContext(EDITOR_SERVICES_KEY);
+    const { stickyColumn, edgeAffinity, selection, reorder, revealAnchor, events: editorEvents, registryView, activePlugins } = getContext(EDITOR_SERVICES_KEY);
     const { keybindingOverrides, presentationMode: getPresentationMode, theme: getTheme } = getContext(EDITOR_POLICIES_KEY);
     const editorDoc = getContext(EDITOR_DOC_KEY);
     const pluginEditor = editorDoc?.pluginEditor;
@@ -344,6 +345,7 @@ export function createContainerBlock(deps) {
         updateOwnMetadata,
         handleKeydown,
         moveFocusOut,
+        captureScrollPosition: () => captureScrollPosition(deps.getBoxEl(), () => revealAnchor.get() !== null),
         getPresentationMode,
         getTheme,
         getOptions

package/dist/editor-props.d.ts

@@ -47,6 +47,9 @@ export interface EditorProps {
      *  available, as is the table's right-click cell menu. */
     blockDragHandles?: boolean;
     searchBar?: boolean;
+    /** The editor's own formatting popover beside a prose selection (default on; reading mode
+     *  never shows it). A host with its own bar over `runCommand` passes false. */
+    selectionToolbar?: boolean;
     /** Where the editor's own find/replace bar renders. Default (absent) keeps it pinned inside
      *  the editor root; an element relocates the SAME bar into it, theme scope included, so
      *  host-scroll embeds can put it in a pane's chrome instead of mid-page. Read live, and

package/dist/plugin.d.ts

@@ -29,7 +29,7 @@ export type { OuterBlockScan } from './schema/block-openers';
 export { OPENER_PRIORITIES } from './schema/opener-priorities';
 export { registerBlockCompleter } from './schema/block-completions';
 export type { BlockCompleter, CompletionResult } from './schema/block-completions';
-export { registerLanguage, listLanguages } from './components/blocks/code/code-languages';
+export { registerLanguage, listLanguages, getLanguageAliases } from './components/blocks/code/code-languages';
 export type { LanguageGrammar } from './components/blocks/code/code-languages';
 export { tokenizeBody as highlightCode } from './components/blocks/code/code-renderer';
 export type { LanguageFn } from 'highlight.js';
@@ -103,6 +103,7 @@ export { caretOffsetAtPoint } from './cursor/point-offset';
 export type { CaretTarget } from './schema/block-kind-descriptor';
 export { CURSOR_END } from './block-component';
 export type { CursorEnd } from './block-component';
+export { POINTER_GESTURE_ATTR } from './selection/pointer-gesture';
 export type { EditorSelection, SelectionPoint } from './selection/primitives';
 export { SELECTION_END } from './block-component';
 export type { SelectionEnd } from './block-component';

package/dist/plugin.js

@@ -43,7 +43,8 @@ export { registerBlockCompleter } from './schema/block-completions';
 // grammar is bundle weight for every consumer), so a host needing more registers them itself,
 // BEFORE mounting an editor: a block on screen re-tokenizes only when its bytes next change.
 // An unregistered language is not an error — the fence still round-trips, just untokenized.
-export { registerLanguage, listLanguages } from './components/blocks/code/code-languages';
+// `listLanguages` lists each language once; `getLanguageAliases` holds the other spellings.
+export { registerLanguage, listLanguages, getLanguageAliases } from './components/blocks/code/code-languages';
 // The code block's own tokenizer, for a plugin whose source surface wants the same highlighting
 // (block math paints its LaTeX with it). Text-preserving: the fragment's textContent is `body`.
 export { tokenizeBody as highlightCode } from './components/blocks/code/code-renderer';
@@ -164,4 +165,8 @@ export { registerPasteTransform } from './tree-operations/paste/paste-transforms
 // names one), and the sentinel for "wherever this leaf ends".
 export { caretOffsetAtPoint } from './cursor/point-offset';
 export { CURSOR_END } from './block-component';
+// ── Pointer gestures (pre-freeze) ────────────────────────────────────────────
+// Put this attribute on an element whose drags are your widget's own (a pan, a brush) and the
+// editor's pointer arms leave a press inside it alone: no block range, no click ladder.
+export { POINTER_GESTURE_ATTR } from './selection/pointer-gesture';
 export { SELECTION_END } from './block-component';

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

@@ -13,37 +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 its closer search would jump to the far end of the next formula on the line.
+    // 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 ─────────────────────────────────────────────────────────────
@@ -61,12 +68,42 @@ 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 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.
@@ -167,26 +204,6 @@ export function registerMathBlock() {
     // Co-registered so one install teaches both forms (the admonition/githubAlert precedent).
     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
 // the same component.

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

@@ -7,10 +7,10 @@ export declare function mathBodySpan(text: string): {
     end: number;
 };
 /**
- * A `$$` block with no body LINE — `$$$$`, `$$\n$$`, a whitespace-only one-liner — has nowhere
+ * 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 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.
+ * 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;

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

@@ -1,38 +1,51 @@
 /**
- * The `$$` block's source as DOM, shaped like a code block's: each fence line in a
+ * 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 } from '../../plugin';
+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) {
-    if (!text.startsWith(FENCE))
-        return { opener: '', body: text, closer: '' };
     const firstNewline = text.indexOf('\n');
-    // One-line form: `$$x^2$$`.
-    if (firstNewline === -1) {
-        if (text.length >= 4 && text.endsWith(FENCE)) {
-            return { opener: FENCE, body: text.slice(2, -2), closer: FENCE };
+    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);
         }
-        return { opener: '', body: text, closer: '' };
+        if (text.slice(0, firstNewline) !== FENCE)
+            return unsliced(text);
+        return sliceFenceLines(text, firstNewline, (line) => line === FENCE);
     }
-    if (text.slice(0, firstNewline) !== FENCE)
-        return { opener: '', body: text, closer: '' };
+    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 (lastLine !== FENCE)
+    if (!isCloser(lastLine))
         return { opener, body: rest, closer: '' };
     if (lastNewline === -1)
-        return { opener, body: '', closer: FENCE };
+        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: FENCE };
+        return { opener, body: bodyWithEnding, closer: lastLine };
     return { opener, body: rest.slice(0, lastNewline), closer: rest.slice(lastNewline) };
 }
 function fenceLine(text) {
@@ -53,21 +66,14 @@ function fenceLine(text) {
  * a point measured against the rendered equation names a place in this span and nowhere else.
  */
 export function mathBodySpan(text) {
-    if (/^[ \t]*(?:`{3,}|~{3,})/.test(text)) {
-        const firstBreak = text.indexOf('\n');
-        if (firstBreak === -1)
-            return { start: text.length, end: text.length };
-        const closer = /(?:\r?\n)?[ \t]*(?:`{3,}|~{3,})[ \t]*\r?\n?$/.exec(text);
-        return { start: firstBreak + 1, end: closer ? closer.index : text.length };
-    }
     const { opener, body } = sliceMathSource(text);
     return { start: opener.length, end: opener.length + body.length };
 }
 /**
- * A `$$` block with no body LINE — `$$$$`, `$$\n$$`, a whitespace-only one-liner — has nowhere
+ * 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 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.
+ * 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);
@@ -75,8 +81,8 @@ export function completeBareMathSource(text) {
         return null;
     if (body.includes('\n') || body.trim() !== '')
         return null;
-    const completed = `${FENCE}\n\n${FENCE}`;
-    return { text: completed, caret: FENCE.length + 1 };
+    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);