@voithos-labs/aragonite 0.10.1

package/dist/core/inline/scan/code-spans.js

@@ -0,0 +1,27 @@
+/**
+ * Backtick handler over the shared run index in ../backticks.ts. A matched span covers fences
+ * plus content; `text` holds raw content bytes, unfolded (display folding is the normalizer's).
+ * An unmatched run stays whole in the pending text, so an inner backtick is never retried.
+ */
+import { findBacktickCloser, indexBacktickRuns } from '../backticks';
+import { appendNode } from './scan-state';
+export function handleBacktick(ctx) {
+    const { raw, pos, end } = ctx;
+    let runEnd = pos;
+    while (runEnd < end && raw[runEnd] === '`')
+        runEnd++;
+    const tickLen = runEnd - pos;
+    if (ctx.backtickRuns === undefined)
+        ctx.backtickRuns = indexBacktickRuns(raw, pos, end);
+    const closeStart = findBacktickCloser(ctx.backtickRuns, tickLen, pos);
+    if (closeStart === -1) {
+        ctx.pos = runEnd;
+        return;
+    }
+    appendNode(ctx, {
+        kind: 'inlineCode',
+        start: pos,
+        end: closeStart + tickLen,
+        text: raw.slice(pos + tickLen, closeStart)
+    });
+}

package/dist/core/inline/scan/emphasis.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Delimiter runs (`*` `_` `~`) and CommonMark §6.2 phase 2 matching: a faithful port of
+ * commonmark.js 0.31.2 processEmphasis (openers_bottom, odd-match on original run lengths,
+ * closer re-use). The reference's two linked lists are overlays here, not pointers on the nodes.
+ * commonmark.js is (c) 2014 John MacFarlane, BSD-2-Clause; see THIRD-PARTY-NOTICES.md.
+ */
+import { type ScanContext } from './scan-state';
+export declare function handleDelimiter(ctx: ScanContext): void;
+/** Matches delimiters at stack index >= floor, then consumes the stack back down to `floor`. */
+export declare function processEmphasis(ctx: ScanContext, floor: number): void;

package/dist/core/inline/scan/emphasis.js

@@ -0,0 +1,276 @@
+/**
+ * Delimiter runs (`*` `_` `~`) and CommonMark §6.2 phase 2 matching: a faithful port of
+ * commonmark.js 0.31.2 processEmphasis (openers_bottom, odd-match on original run lengths,
+ * closer re-use). The reference's two linked lists are overlays here, not pointers on the nodes.
+ * commonmark.js is (c) 2014 John MacFarlane, BSD-2-Clause; see THIRD-PARTY-NOTICES.md.
+ */
+import { assertInvariant } from '../../../assert';
+import { appendNode } from './scan-state';
+// ── Flanking classification (§6.2 phase 1) ──────────────────────────────────
+/** Unicode punctuation (ASCII punctuation + general category P). */
+function isPunct(ch) {
+    if (!ch)
+        return false;
+    const code = ch.codePointAt(0);
+    if ((code >= 0x21 && code <= 0x2f) ||
+        (code >= 0x3a && code <= 0x40) ||
+        (code >= 0x5b && code <= 0x60) ||
+        (code >= 0x7b && code <= 0x7e)) {
+        return true;
+    }
+    return /^\p{P}$/u.test(ch);
+}
+function isWhitespace(ch) {
+    if (!ch)
+        return true; // string boundary counts as whitespace
+    return /\s/.test(ch);
+}
+// Flanking neighbors are read as full code points: a UTF-16 unit read would classify an
+// astral neighbor as a lone surrogate, while the spec defines the classes over code points.
+function codePointBefore(raw, pos) {
+    const unit = raw.charCodeAt(pos - 1);
+    if (unit >= 0xdc00 && unit <= 0xdfff && pos >= 2) {
+        const high = raw.charCodeAt(pos - 2);
+        if (high >= 0xd800 && high <= 0xdbff)
+            return raw.slice(pos - 2, pos);
+    }
+    return raw[pos - 1];
+}
+/**
+ * CommonMark §6.2 flanking over code points. Neighbors are read from raw unclamped: context
+ * outside [start, end) still counts, as the spec's source-text reading implies.
+ */
+function classifyDelimiterRun(raw, runStart, runEnd, kind) {
+    const charBefore = runStart > 0 ? codePointBefore(raw, runStart) : '';
+    const charAfter = runEnd < raw.length ? String.fromCodePoint(raw.codePointAt(runEnd)) : '';
+    const followedByWhitespace = isWhitespace(charAfter);
+    const followedByPunct = isPunct(charAfter);
+    const precededByWhitespace = isWhitespace(charBefore);
+    const precededByPunct = isPunct(charBefore);
+    const leftFlanking = !followedByWhitespace && (!followedByPunct || precededByWhitespace || precededByPunct);
+    const rightFlanking = !precededByWhitespace && (!precededByPunct || followedByWhitespace || followedByPunct);
+    if (kind === '*' || kind === '~') {
+        return { canOpen: leftFlanking, canClose: rightFlanking };
+    }
+    // `_` has extra restrictions to avoid intra-word emphasis.
+    const canOpen = leftFlanking && (!rightFlanking || precededByPunct);
+    const canClose = rightFlanking && (!leftFlanking || followedByPunct);
+    return { canOpen, canClose };
+}
+// ── Scan-time handler ───────────────────────────────────────────────────────
+export function handleDelimiter(ctx) {
+    const { raw, pos, end } = ctx;
+    const char = raw[pos];
+    let runEnd = pos + 1;
+    while (runEnd < end && raw[runEnd] === char)
+        runEnd++;
+    const length = runEnd - pos;
+    // cmark-gfm delimits strikethrough in tilde runs of length 1 or 2; a run of 3+ never
+    // participates. The mixed-length non-pairing rule lives at the match, in processEmphasis.
+    if (char === '~' && length > 2) {
+        ctx.pos = runEnd;
+        return;
+    }
+    const { canOpen, canClose } = classifyDelimiterRun(raw, pos, runEnd, char);
+    if (!canOpen && !canClose) {
+        ctx.pos = runEnd;
+        return;
+    }
+    const node = { kind: 'text', start: pos, end: runEnd, text: raw.slice(pos, runEnd) };
+    appendNode(ctx, node);
+    ctx.delimiters.push({ node, char, length, origLength: length, canOpen, canClose });
+}
+// ── §6.2 phase 2 ────────────────────────────────────────────────────────────
+/** Matches delimiters at stack index >= floor, then consumes the stack back down to `floor`. */
+export function processEmphasis(ctx, floor) {
+    const { delimiters } = ctx;
+    const top = delimiters.length;
+    if (top === floor)
+        return;
+    const bottom = floor - 1; // sentinel index standing in for the reference's stack_bottom
+    const win = openNodeWindow(ctx, delimiters[floor].node);
+    const slotOf = mapDelimiterSlots(win, delimiters, floor, top);
+    if (slotOf === null) {
+        // Warn rather than throw: the state is unreachable today, and a false positive must not
+        // take a real editor's block to the fallback. The runs left behind stay literal text.
+        assertInvariant('emphasis-run-node-live', () => ({
+            code: 'emphasis-run-node-missing',
+            message: 'a live delimiter run node was not in the working node list, so the emphasis pass ' +
+                'for this range was dropped and its pairs will not form',
+            detail: { floor, top, windowSize: win.slot.length }
+        }));
+        delimiters.length = floor;
+        return;
+    }
+    // Linked overlay over stack indices [floor, top): retired delimiters unlink in O(1) without
+    // splicing the shared stack (Bracket.delimiterFloor and openers_bottom index into it).
+    const prev = new Array(top);
+    const next = new Array(top);
+    for (let i = floor; i < top; i++) {
+        prev[i] = i - 1;
+        next[i] = i + 1;
+    }
+    const unlink = (i) => {
+        if (prev[i] > bottom)
+            next[prev[i]] = next[i];
+        if (next[i] < top)
+            prev[next[i]] = prev[i];
+    };
+    // openers_bottom: per (char, closer canOpen, closer origLength % 3), the position below which
+    // this closer class has proven no opener exists. Keeps repeated failed searches amortized O(1).
+    const openersBottom = new Array(18).fill(bottom);
+    let ci = floor;
+    while (ci < top) {
+        const closer = delimiters[ci];
+        if (!closer.canClose) {
+            ci = next[ci];
+            continue;
+        }
+        const bucket = CHAR_BUCKET[closer.char] + (closer.canOpen ? 3 : 0) + (closer.origLength % 3);
+        const stopAt = openersBottom[bucket];
+        let opener = null;
+        let oi = prev[ci];
+        while (oi > bottom && oi !== stopAt) {
+            const candidate = delimiters[oi];
+            if (candidate.char === closer.char &&
+                candidate.canOpen &&
+                !isOddMatch(candidate, closer) &&
+                tildeLengthsAgree(candidate, closer)) {
+                opener = candidate;
+                break;
+            }
+            oi = prev[oi];
+        }
+        if (opener === null) {
+            openersBottom[bucket] = prev[ci];
+            const after = next[ci];
+            if (!closer.canOpen)
+                unlink(ci);
+            ci = after;
+            continue;
+        }
+        wrapMatch(win, ctx.raw, opener, closer, slotOf[oi], slotOf[ci]);
+        // Delimiters between the pair moved inside the wrap: retire them.
+        next[oi] = ci;
+        prev[ci] = oi;
+        if (opener.length === 0)
+            unlink(oi);
+        if (closer.length === 0) {
+            const after = next[ci];
+            unlink(ci);
+            ci = after;
+        }
+        // A closer with remaining length retries against earlier openers.
+    }
+    closeNodeWindow(ctx, win);
+    delimiters.length = floor;
+}
+const CHAR_BUCKET = { '*': 0, _: 6, '~': 12 };
+/** §6.2 multiple-of-3 rule, on ORIGINAL run lengths (commonmark.js `origdelims`). */
+function isOddMatch(opener, closer) {
+    return ((closer.canOpen || opener.canClose) &&
+        closer.origLength % 3 !== 0 &&
+        (opener.origLength + closer.origLength) % 3 === 0);
+}
+/**
+ * cmark-gfm pairs strikethrough runs only at equal length. A gate of its own: the multiple-of-3
+ * rule misses the flanking-pure `~a~~` / `~~a~` shapes, and `*`/`_` carry no such rule.
+ */
+function tildeLengthsAgree(opener, closer) {
+    return closer.char !== '~' || opener.origLength === closer.origLength;
+}
+function wrapMatch(win, raw, opener, closer, openerSlot, closerSlot) {
+    const use = opener.length >= 2 && closer.length >= 2 ? 2 : 1;
+    const kind = opener.char === '~' ? 'strikethrough' : use === 2 ? 'strong' : 'emphasis';
+    // The NONE arm only bounds this walk. What rules out cycling the list closeNodeWindow walks
+    // is the caller's contract (slots ascend with scan order, relinks skip forward), not this arm.
+    const children = [];
+    for (let i = win.next[openerSlot]; i !== closerSlot && i !== NONE; i = win.next[i]) {
+        children.push(win.slot[i]);
+    }
+    win.next[openerSlot] = closerSlot;
+    win.prev[closerSlot] = openerSlot;
+    const wrapped = {
+        kind,
+        start: opener.node.end - use,
+        end: closer.node.start + use,
+        children
+    };
+    opener.length -= use;
+    opener.node.end -= use;
+    opener.node.text = raw.slice(opener.node.start, opener.node.end);
+    closer.length -= use;
+    closer.node.start += use;
+    closer.node.text = raw.slice(closer.node.start, closer.node.end);
+    insertNodeAfter(win, openerSlot, wrapped);
+    if (opener.length === 0)
+        unlinkNode(win, openerSlot);
+    if (closer.length === 0)
+        unlinkNode(win, closerSlot);
+}
+// ── Working-node window ─────────────────────────────────────────────────────
+const NONE = -1;
+/**
+ * Nodes before `first` are out of every reachable match's range, so leaving them in place is
+ * what keeps a bracket's recorded node position valid across the pass.
+ */
+function openNodeWindow(ctx, first) {
+    let base = ctx.nodes.length - 1;
+    while (base > 0 && ctx.nodes[base] !== first)
+        base--;
+    const slot = ctx.nodes.slice(base);
+    const prev = new Array(slot.length);
+    const next = new Array(slot.length);
+    for (let i = 0; i < slot.length; i++) {
+        prev[i] = i - 1; // slot 0 lands on NONE
+        next[i] = i + 1 < slot.length ? i + 1 : NONE;
+    }
+    return { slot, prev, next, head: 0, base };
+}
+function closeNodeWindow(ctx, win) {
+    const { nodes } = ctx;
+    nodes.length = win.base;
+    // One at a time: spreading a window this size hits V8's argument limit, and that
+    // RangeError takes the block to the unhealable failed-block fallback.
+    for (let i = win.head; i !== NONE; i = win.next[i])
+        nodes.push(win.slot[i]);
+}
+function unlinkNode(win, i) {
+    const before = win.prev[i];
+    const after = win.next[i];
+    if (before === NONE)
+        win.head = after;
+    else
+        win.next[before] = after;
+    if (after !== NONE)
+        win.prev[after] = before;
+}
+function insertNodeAfter(win, at, node) {
+    const i = win.slot.length;
+    win.slot.push(node);
+    const after = win.next[at];
+    win.prev[i] = at;
+    win.next[i] = after;
+    win.next[at] = i;
+    if (after !== NONE)
+        win.prev[after] = i;
+}
+/**
+ * Delimiters and their run nodes are both in scan order, so one merge walk places them all.
+ * Null when a run node is missing: the pass's precondition broke upstream, and the caller must
+ * drop the pass rather than walk off a linked list that has no end.
+ */
+function mapDelimiterSlots(win, delimiters, floor, top) {
+    const slotOf = new Array(top);
+    let s = 0;
+    for (let d = floor; d < top; d++) {
+        const node = delimiters[d].node;
+        while (s < win.slot.length && win.slot[s] !== node)
+            s++;
+        if (s === win.slot.length)
+            return null;
+        slotOf[d] = s;
+        s++;
+    }
+    return slotOf;
+}

package/dist/core/inline/scan/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Single-pass inline scanner (the CommonMark reference architecture), exported as `parseInline`
+ * from ../index.ts. Contract: InlineNode[] with absolute offsets into raw, covering [start, end).
+ */
+import { type InlineNode } from '../../nodes';
+import type { LinkReferenceResolver } from '../link-reference-resolver';
+export declare function scanInline(raw: string, start: number, end: number, resolver?: LinkReferenceResolver): InlineNode[];

package/dist/core/inline/scan/index.js

@@ -0,0 +1,176 @@
+/**
+ * Single-pass inline scanner (the CommonMark reference architecture), exported as `parseInline`
+ * from ../index.ts. Contract: InlineNode[] with absolute offsets into raw, covering [start, end).
+ */
+import { isBuiltinInlineKind } from '../../nodes';
+import { inlineDescendants } from '../walk';
+import { handleAngle, scanGfmAutolinks } from './autolinks';
+import { handleBang, handleCloseBracket, handleOpenBracket } from './brackets';
+import { handleBacktick } from './code-spans';
+import { handleDelimiter, processEmphasis } from './emphasis';
+import { appendNode, createScanContext, flushPendingText, mergeAdjacentText } from './scan-state';
+import { handleAmpersand, handleBackslash, handleNewline } from './simple-nodes';
+import { getPrefixRungs, getUnreservedRungs, hasInlineSyntax, hasPrefixRungs, hasScanProbeRungs, isScanProbeTrigger } from './plugin-syntax';
+// Every character that can start a construct or anchor a lookback: the dispatch cases below
+// plus `@` (GFM email lookback). `!` and `]` are deliberately absent, mattering only in ranges
+// that also contain `[`; a plugin rung makes `!` visible per registration (plugin-syntax.ts).
+const SPECIAL_CHARS = '\\`&\n<[*_~@';
+// GFM bare http/www autolinks contain no character from the set above, so their starts get
+// conditional probes: `:` counts only when `//` follows, `w`/`W` only on a `www.` prefix. The
+// lookahead may read past `end` and over-trigger, which costs one wasted scan, never a node.
+const PROBE_SCHEME = 2;
+const PROBE_WWW = 3;
+const SPECIAL = new Uint8Array(128);
+for (let i = 0; i < SPECIAL_CHARS.length; i++)
+    SPECIAL[SPECIAL_CHARS.charCodeAt(i)] = 1;
+SPECIAL[0x3a] = PROBE_SCHEME; // :
+SPECIAL[0x57] = PROBE_WWW; // W
+SPECIAL[0x77] = PROBE_WWW; // w
+/** Fast bail for the per-keystroke hot path: plain prose skips the scan loop. */
+function needsScan(raw, start, end) {
+    // Registered plugin triggers are held out of SPECIAL_CHARS, so probe them only when
+    // something is registered; an unregistered scan pays one always-false test per character.
+    const probePlugins = hasScanProbeRungs();
+    for (let i = start; i < end; i++) {
+        const code = raw.charCodeAt(i);
+        if (code >= 128) {
+            if (probePlugins && isScanProbeTrigger(raw[i]))
+                return true;
+            continue;
+        }
+        const cls = SPECIAL[code];
+        if (cls === 0) {
+            if (probePlugins && isScanProbeTrigger(raw[i]))
+                return true; // registered '!' lands here
+            continue;
+        }
+        if (cls === 1)
+            return true;
+        if (cls === PROBE_SCHEME) {
+            if (raw.charCodeAt(i + 1) === 0x2f && raw.charCodeAt(i + 2) === 0x2f)
+                return true; // ://
+            if (probePlugins && isScanProbeTrigger(raw[i]))
+                return true; // registered ':'
+        }
+        else {
+            if ((raw.charCodeAt(i + 1) | 0x20) === 0x77 &&
+                (raw.charCodeAt(i + 2) | 0x20) === 0x77 &&
+                raw.charCodeAt(i + 3) === 0x2e) {
+                return true; // www.
+            }
+            if (probePlugins && isScanProbeTrigger(raw[i]))
+                return true; // registered 'w'/'W'
+        }
+    }
+    return false;
+}
+// Try a trigger's rungs in dispatch order: the first whose prefix matches at `ctx.pos` and whose
+// recognizer claims wins. Claim validation lives here once, on both dispatch paths, and sits past
+// the decline so a declining rung pays none of it and leaves `ctx` byte-identical.
+function tryRungs(ctx, rungs) {
+    if (!rungs)
+        return null;
+    const { raw, pos, end } = ctx;
+    for (const rung of rungs) {
+        if (!raw.startsWith(rung.prefix, pos))
+            continue;
+        const node = rung.recognizer(raw, pos, end);
+        if (!node)
+            continue;
+        if (node.start !== pos) {
+            throw new Error(`inline-syntax "${rung.prefix}" started at ${node.start}, expected ${pos}`);
+        }
+        if (node.end <= pos) {
+            throw new Error(`inline-syntax "${rung.prefix}" did not advance`);
+        }
+        // A block's scan range is not always its raw (a heading's excludes the closing `#` run, a
+        // table cell's the `|`), so a recognizer searching the STRING claims bytes the block still
+        // needs, and the overrun leaves no trace beyond wrong caret offsets. Half-open: ending AT
+        // `end` is ordinary, only past it is a fault.
+        if (node.end > end) {
+            throw new Error(`inline-syntax "${rung.prefix}" claimed [${node.start}, ${node.end}), past the scan ` +
+                `range end ${end} — a recognizer must bound its search by the \`end\` it is given`);
+        }
+        stampClaim(node, rung);
+        return node;
+    }
+    return null;
+}
+// A rung minting a BUILT-IN kind borrows the editor's model for bytes of its own, and the
+// editor's inverse emits built-in grammar, so an image minted over `![[cat.png]]` would resize
+// into GFM and take the author's syntax with it. Descendants stamp on the same rule; a rung's
+// own kind needs no stamp. Assigned, never merged, so a recognizer cannot name its own claimer.
+function stampClaim(node, claim) {
+    for (const inline of inlineDescendants([node])) {
+        if (isBuiltinInlineKind(inline.kind))
+            inline.syntaxClaim = claim;
+    }
+}
+export function scanInline(raw, start, end, resolver) {
+    if (start >= end)
+        return [];
+    if (!needsScan(raw, start, end)) {
+        return [{ kind: 'text', start, end, text: raw.slice(start, end) }];
+    }
+    const ctx = createScanContext(raw, start, end, resolver);
+    // Reserved-trigger prefix rungs are consulted before the switch so they can outrank a
+    // built-in case: a handler consumes its trigger and advances (`handleBang` eats `![` whole),
+    // so the scan never returns to a position the switch has read. Hoisted for the empty registry.
+    const consultPrefixRungs = hasPrefixRungs();
+    while (ctx.pos < ctx.end) {
+        if (consultPrefixRungs) {
+            const node = tryRungs(ctx, getPrefixRungs(raw[ctx.pos]));
+            if (node) {
+                appendNode(ctx, node);
+                continue;
+            }
+        }
+        switch (raw[ctx.pos]) {
+            case '\\':
+                handleBackslash(ctx);
+                break;
+            case '`':
+                handleBacktick(ctx);
+                break;
+            case '&':
+                handleAmpersand(ctx);
+                break;
+            case '\n':
+                handleNewline(ctx);
+                break;
+            case '*':
+            case '_':
+            case '~':
+                handleDelimiter(ctx);
+                break;
+            case '[':
+                handleOpenBracket(ctx);
+                break;
+            case ']':
+                handleCloseBracket(ctx);
+                break;
+            case '!':
+                handleBang(ctx);
+                break;
+            case '<':
+                handleAngle(ctx);
+                break;
+            default: {
+                if (hasInlineSyntax()) {
+                    const node = tryRungs(ctx, getUnreservedRungs(raw[ctx.pos]));
+                    if (node) {
+                        appendNode(ctx, node);
+                        break;
+                    }
+                }
+                ctx.pos++;
+            }
+        }
+    }
+    flushPendingText(ctx, ctx.end);
+    // GFM bare autolinks claim their bytes before emphasis pairs: a delimiter
+    // absorbed into a URL must not pair.
+    scanGfmAutolinks(ctx);
+    processEmphasis(ctx, 0);
+    return mergeAdjacentText(ctx.nodes);
+}

package/dist/core/inline/scan/plugin-syntax.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Unstable-public hook for plugin inline syntax: a priority ladder mirroring `OPENER_PRIORITIES`.
+ * One trigger character plus an optional prefix beginning with it, dispatched low-priority-first
+ * so a plugin can outrank a built-in trigger on a longer prefix (footnotes' `[^` beating `[`).
+ * Reserved triggers hold pre-switch rungs, all others hold `default`-arm rungs (scan/index.ts).
+ */
+import type { ImageSyntaxRewriter, InlineNode, InlineSyntaxClaim } from '../../nodes';
+/**
+ * Inspect `raw` at `pos` (the trigger) within `[pos, end)`. Return a node with `start === pos`
+ * and `pos < node.end <= end` to claim that span (`node.end` is the scan advance), or `null` to
+ * leave the trigger literal. `end` bounds the search too: `raw` is the whole block while the
+ * range may be a slice of it, so a terminator past `end` must decline. Claiming past it throws.
+ */
+export type InlineSyntaxRecognizer = (raw: string, pos: number, end: number) => InlineNode | null;
+/** The priority ladder every registration prices against; lower is consulted first. */
+export declare const INLINE_PRIORITIES: {
+    /** Rungs consulted before a reserved trigger's built-in handling. */
+    readonly prefixOverride: 40;
+    /** The switch's own anchor; not registerable. */
+    readonly builtin: 50;
+    /** Default rung for bare-trigger registrations. */
+    readonly plugin: 100;
+};
+export interface InlineSyntaxOptions {
+    /**
+     * Multi-char prefix beginning with the trigger; required for a reserved trigger. Consulted
+     * ahead of the built-in case, so a prefix that also opens a built-in construct outranks it
+     * and the recognizer must decline the overlap itself. Getting that wrong is silent; see the
+     * plugin guide's reserved-trigger section.
+     */
+    prefix?: string;
+    /** Rung; lower is consulted first. Defaults to `INLINE_PRIORITIES.plugin`. */
+    priority?: number;
+    /**
+     * Re-serializer for the built-in `image` nodes this recognizer mints; without it the editor
+     * declines those edits rather than writing GFM over the claimed bytes. Return `null` for
+     * anything your grammar cannot hold: source-identical bytes are dropped silently by the
+     * commit's equality guard. See the plugin guide's inline section.
+     */
+    rewriteImage?: ImageSyntaxRewriter;
+}
+export interface InlineRung extends InlineSyntaxClaim {
+    recognizer: InlineSyntaxRecognizer;
+    priority: number;
+}
+export declare function registerInlineSyntax(trigger: string, recognizer: InlineSyntaxRecognizer, options?: InlineSyntaxOptions): void;
+/**
+ * Whether the built-in scanner claims `trigger` through a `case` arm. A rung on one is consulted
+ * BEFORE that arm, so it owes the overlap a decline; the conformance kit refuses it an exemption.
+ */
+export declare function isReservedInlineTrigger(trigger: string): boolean;
+/** Rungs for a trigger in dispatch order, reserved-aware. Empty when none. */
+export declare function getInlineRungs(trigger: string): readonly InlineRung[];
+export declare function getUnreservedRungs(char: string): InlineRung[] | undefined;
+export declare function getPrefixRungs(char: string): InlineRung[] | undefined;
+export declare function hasInlineSyntax(): boolean;
+/** Read once per scan, so an empty set leaves `needsScan` at its pre-plugin cost. */
+export declare function hasScanProbeRungs(): boolean;
+export declare function isScanProbeTrigger(char: string): boolean;
+/** False costs the scan loop nothing. */
+export declare function hasPrefixRungs(): boolean;
+export declare function __resetInlineSyntaxForTests(): void;