@tabnas/markdown 0.6.2 → 0.7.2

package/dist/engine-block.d.ts

@@ -0,0 +1,69 @@
+import type { Context, MakeLexMatcher, Rule, Tabnas } from '@tabnas/parser';
+import { BlockParser } from './block.ts';
+import type { MdNode } from './node.ts';
+import type { ParserOptions } from './options.ts';
+/** The `#LB` token's `use` payload: one physical line, pre-classified. */
+export type LineInfo = {
+    /** The line's text, terminator excluded, NULs already replaced. */
+    text: string;
+    /** True when the line holds nothing but spaces and tabs. */
+    blank: boolean;
+    /**
+     * GFM table arming: true when the line contains a `|` or a `-` anywhere.
+     * A deliberate, *provable* superset of "could be a delimiter row": every
+     * delimiter cell requires at least one `-` (`:-:` rows open pipe-less
+     * single-column tables), and multi-column rows carry `|`. The real
+     * decision needs the container-adjusted offset only the block algorithm
+     * knows — a delimiter row nested in a block quote matches after the `>`
+     * marker — so the `gfm`-tagged alt reading this bit only *arms* the
+     * probe, and `tryOpenTable` re-verifies (see test/spec/mixed.tsv).
+     */
+    tblArm: boolean;
+};
+/** The per-parse state carried on `ctx.u.md` — seeded by `parse.prepare`. */
+export type MdParseState = {
+    bp: BlockParser;
+    meta: Record<string, any> | undefined;
+};
+/**
+ * Build the `mdLine` matcher: each invocation consumes one physical line —
+ * terminator included — and emits a single `#LB` token carrying the line as
+ * `LineInfo`. The matcher owns the engine's point: `sI` advances past the
+ * terminator, `rI` counts rows, and `cI` resets per line (the engine's
+ * column is not used for indentation — the shared `BlockParser` computes
+ * spec §2.2 tab-expanded columns itself).
+ */
+export declare const makeMdLineMatcher: MakeLexMatcher;
+/**
+ * The three named actions of the `markdown`/`line` rules. Bound to resolved
+ * options at plugin-install time, exactly as the engine-free entry points
+ * are. `runInlines` is the phase-2 driver — the engine inline path from
+ * `engine-inline.ts` — injected so this module stays a block-phase concern.
+ */
+export declare function makeMdActions(opts: ParserOptions, runInlines: (doc: MdNode, refmap: Record<string, any>) => void): {
+    /** `parse.prepare`: fresh block-parser state for every parse. */
+    prepare: (_tn: Tabnas, ctx: Context, meta?: any) => void;
+    /**
+     * `line` base open alt: disarm the table probe and feed the matched
+     * `#LB` line to the shared algorithm. Reaching this alt means the
+     * `gfm`-tagged alt above it did not match — the line cannot contain a
+     * delimiter row — or GFM is off entirely (`rule.exclude` removed the
+     * tagged alt, and `tryOpenTable` is closed by the option anyway).
+     */
+    line: (r: Rule, ctx: Context) => void;
+    /**
+     * `line` GFM open alt (tagged `g: 'gfm'`, condition on the token's
+     * `tblArm` bit): arm the table probe for this line, then feed it to the
+     * same shared algorithm. This is the extension seam a downstream
+     * dialect would use — an alt injected ahead of the base one, gated on
+     * a group tag so `gfm: false` can subtract it wholesale.
+     */
+    lineGfm: (r: Rule, ctx: Context) => void;
+    /**
+     * `markdown` close alt (`#ZZ`): finalize blocks, run the shared inline
+     * phase, and project the public AST into the rule's node. When the
+     * caller passed `meta.md.keepTree`, the native tree is handed back on
+     * the meta object — the engine-path conformance harness renders it.
+     */
+    finish: (r: Rule, ctx: Context) => void;
+};

package/dist/engine-block.js

@@ -0,0 +1,99 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMdLineMatcher = void 0;
+exports.makeMdActions = makeMdActions;
+const block_ts_1 = require("./block.js");
+const ast_ts_1 = require("./ast.js");
+/**
+ * Build the `mdLine` matcher: each invocation consumes one physical line —
+ * terminator included — and emits a single `#LB` token carrying the line as
+ * `LineInfo`. The matcher owns the engine's point: `sI` advances past the
+ * terminator, `rI` counts rows, and `cI` resets per line (the engine's
+ * column is not used for indentation — the shared `BlockParser` computes
+ * spec §2.2 tab-expanded columns itself).
+ */
+const makeMdLineMatcher = (_cfg, _opts) => {
+    return (lex, _rule) => {
+        const pnt = lex.pnt;
+        const src = lex.src;
+        const seg = (0, block_ts_1.segmentNextLine)(src, pnt.sI);
+        if (null === seg)
+            return undefined;
+        const info = {
+            text: seg.text,
+            blank: (0, block_ts_1.isBlank)(seg.text),
+            tblArm: -1 !== seg.text.indexOf('|') || -1 !== seg.text.indexOf('-'),
+        };
+        const tkn = lex.token('#LB', seg.text, src.slice(pnt.sI, seg.next), pnt, info);
+        // Row/column bookkeeping is observability data (#ZZ position, traces):
+        // a consumed terminator starts a new row; an unterminated final line
+        // just widens the current one.
+        const terminated = seg.next > pnt.sI + seg.text.length;
+        pnt.sI = seg.next;
+        if (terminated) {
+            pnt.rI += 1;
+            pnt.cI = 1;
+        }
+        else {
+            pnt.cI += seg.text.length;
+        }
+        return tkn;
+    };
+};
+exports.makeMdLineMatcher = makeMdLineMatcher;
+/**
+ * The three named actions of the `markdown`/`line` rules. Bound to resolved
+ * options at plugin-install time, exactly as the engine-free entry points
+ * are. `runInlines` is the phase-2 driver — the engine inline path from
+ * `engine-inline.ts` — injected so this module stays a block-phase concern.
+ */
+function makeMdActions(opts, runInlines) {
+    return {
+        /** `parse.prepare`: fresh block-parser state for every parse. */
+        prepare: (_tn, ctx, meta) => {
+            const state = { bp: new block_ts_1.BlockParser(opts), meta };
+            ctx.u.md = state;
+        },
+        /**
+         * `line` base open alt: disarm the table probe and feed the matched
+         * `#LB` line to the shared algorithm. Reaching this alt means the
+         * `gfm`-tagged alt above it did not match — the line cannot contain a
+         * delimiter row — or GFM is off entirely (`rule.exclude` removed the
+         * tagged alt, and `tryOpenTable` is closed by the option anyway).
+         */
+        line: (r, ctx) => {
+            const state = ctx.u.md;
+            state.bp.tableArmed = false;
+            state.bp.incorporateLine(r.o0.use.text);
+        },
+        /**
+         * `line` GFM open alt (tagged `g: 'gfm'`, condition on the token's
+         * `tblArm` bit): arm the table probe for this line, then feed it to the
+         * same shared algorithm. This is the extension seam a downstream
+         * dialect would use — an alt injected ahead of the base one, gated on
+         * a group tag so `gfm: false` can subtract it wholesale.
+         */
+        lineGfm: (r, ctx) => {
+            const state = ctx.u.md;
+            state.bp.tableArmed = true;
+            state.bp.incorporateLine(r.o0.use.text);
+        },
+        /**
+         * `markdown` close alt (`#ZZ`): finalize blocks, run the shared inline
+         * phase, and project the public AST into the rule's node. When the
+         * caller passed `meta.md.keepTree`, the native tree is handed back on
+         * the meta object — the engine-path conformance harness renders it.
+         */
+        finish: (r, ctx) => {
+            const state = ctx.u.md;
+            const { doc, refmap } = state.bp.finish();
+            runInlines(doc, refmap);
+            const md = state.meta && state.meta.md;
+            if (md && true === md.keepTree)
+                md.tree = doc;
+            r.node = (0, ast_ts_1.toAst)(doc, opts);
+        },
+    };
+}
+//# sourceMappingURL=engine-block.js.map

package/dist/engine-block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-block.js","sourceRoot":"","sources":["../src/engine-block.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;AAgGpD,sCAsDC;AAlID,yCAAkE;AAClE,qCAAgC;AA6BhC;;;;;;;GAOG;AACI,MAAM,iBAAiB,GAAmB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;IAC/D,OAAO,CAAC,GAAQ,EAAE,KAAW,EAAE,EAAE;QAC/B,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAA;QACnB,MAAM,GAAG,GAAW,GAAG,CAAC,GAAG,CAAA;QAE3B,MAAM,GAAG,GAAG,IAAA,0BAAe,EAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA;QACxC,IAAI,IAAI,KAAK,GAAG;YAAE,OAAO,SAAS,CAAA;QAElC,MAAM,IAAI,GAAa;YACrB,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,KAAK,EAAE,IAAA,kBAAO,EAAC,GAAG,CAAC,IAAI,CAAC;YACxB,MAAM,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;SACrE,CAAA;QAED,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;QAE9E,uEAAuE;QACvE,qEAAqE;QACrE,+BAA+B;QAC/B,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,MAAM,CAAA;QACtD,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,CAAA;QACjB,IAAI,UAAU,EAAE,CAAC;YACf,GAAG,CAAC,EAAE,IAAI,CAAC,CAAA;YACX,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;QACZ,CAAC;aAAM,CAAC;YACN,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAA;QAC3B,CAAC;QAED,OAAO,GAAG,CAAA;IACZ,CAAC,CAAA;AACH,CAAC,CAAA;AA9BY,QAAA,iBAAiB,qBA8B7B;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAC3B,IAAmB,EACnB,UAA8D;IAE9D,OAAO;QACL,iEAAiE;QACjE,OAAO,EAAE,CAAC,GAAW,EAAE,GAAY,EAAE,IAAU,EAAE,EAAE;YACjD,MAAM,KAAK,GAAiB,EAAE,EAAE,EAAE,IAAI,sBAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAC9D;YAAC,GAAG,CAAC,CAAS,CAAC,EAAE,GAAG,KAAK,CAAA;QAC5B,CAAC;QAED;;;;;;WAMG;QACH,IAAI,EAAE,CAAC,CAAO,EAAE,GAAY,EAAE,EAAE;YAC9B,MAAM,KAAK,GAAkB,GAAG,CAAC,CAAS,CAAC,EAAE,CAAA;YAC7C,KAAK,CAAC,EAAE,CAAC,UAAU,GAAG,KAAK,CAAA;YAC3B,KAAK,CAAC,EAAE,CAAC,eAAe,CAAE,CAAC,CAAC,EAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAClD,CAAC;QAED;;;;;;WAMG;QACH,OAAO,EAAE,CAAC,CAAO,EAAE,GAAY,EAAE,EAAE;YACjC,MAAM,KAAK,GAAkB,GAAG,CAAC,CAAS,CAAC,EAAE,CAAA;YAC7C,KAAK,CAAC,EAAE,CAAC,UAAU,GAAG,IAAI,CAAA;YAC1B,KAAK,CAAC,EAAE,CAAC,eAAe,CAAE,CAAC,CAAC,EAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAClD,CAAC;QAED;;;;;WAKG;QACH,MAAM,EAAE,CAAC,CAAO,EAAE,GAAY,EAAE,EAAE;YAChC,MAAM,KAAK,GAAkB,GAAG,CAAC,CAAS,CAAC,EAAE,CAAA;YAC7C,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAA;YACzC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;YAEvB,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAA;YACtC,IAAI,EAAE,IAAI,IAAI,KAAK,EAAE,CAAC,QAAQ;gBAAE,EAAE,CAAC,IAAI,GAAG,GAAa,CAAA;YAEvD,CAAC,CAAC,IAAI,GAAG,IAAA,cAAK,EAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QAC3B,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/engine-inline.d.ts

@@ -0,0 +1,25 @@
+import { Tabnas } from '@tabnas/parser';
+import { InlineParser } from './inline.ts';
+import type { MdNode } from './node.ts';
+import type { ParserOptions, RefMap } from './options.ts';
+/** The per-parse state carried on `ctx.u.inl` — seeded by `parse.prepare`. */
+export type InlineState = {
+    parser: InlineParser;
+    block: MdNode;
+};
+/** The inline token alphabet, in the order the rule's alt lists them. */
+export declare const INLINE_TOKENS: string[];
+/**
+ * Build the package-private inline engine instance for one option set. All
+ * built-in matchers are disabled; the matcher set above is the complete
+ * lexical description of the inline phase.
+ */
+export declare function makeInlineTn(opts: ParserOptions): Tabnas;
+/**
+ * The engine-path inline phase: the same block walk as `parseInlines`, with
+ * each block's scan driven by the engine instance's lexer. An empty subject
+ * never reaches the engine (its empty-source path returns before the rules
+ * run), and finishes the block directly — a no-op resolve, exactly as the
+ * hand scanner's `parse` does.
+ */
+export declare function parseInlinesEngine(inlineTn: Tabnas, doc: MdNode, refmap: RefMap, options: ParserOptions): void;

package/dist/engine-inline.js

@@ -0,0 +1,237 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INLINE_TOKENS = void 0;
+exports.makeInlineTn = makeInlineTn;
+exports.parseInlinesEngine = parseInlinesEngine;
+// The engine-facing inline driver: a second, package-private engine instance
+// whose lexer IS the inline scanner. Each custom matcher is a thin adapter
+// over one `InlineParser` scanner method — the same methods the engine-free
+// path runs — so the anti-drift rule holds: recognition, node building, the
+// delimiter stack and the bracket stack all live once, in `inline.ts`.
+//
+// Two engine features carry the design:
+//
+// * **Context-sensitive matchers.** Every adapter reaches the per-parse
+//   state through `lex.ctx.u.inl`. That is what makes the `]` matcher the
+//   cursor owner: `parseCloseBracket` consumes a successful link tail
+//   directly from the subject, and because that happens at *lex* time, the
+//   engine's point advances past the tail and everything after it is lexed
+//   fresh. The corpus-blind straddle cases (a backtick inside a successful
+//   destination or title, followed by a code span — see test/spec/mixed.tsv)
+//   are correct by construction: no token is ever cut across a tail
+//   boundary, so no re-lex or resynchronization machinery exists at all.
+//
+// * **Matcher order as precedence.** At `<`, the autolink adapter runs
+//   before the raw-HTML adapter, exactly as the hand scanner's dispatch
+//   tries them; the text-run adapter and the single-character literal
+//   fallback come last. The registered order *is* §6.3's precedence table,
+//   visible in the instance's configuration instead of buried in a switch.
+//
+// The one-token effects are applied at lex time on purpose. The engine's
+// rule loop reads lookahead tokens before earlier alts' actions run, so any
+// state a matcher consults — the tree for break trimming, the bracket stack
+// for `]` — must be current when the *lexer* reaches it, not when the
+// parser does. The `inline` rule therefore carries no per-token actions:
+// the tokens are the observable record of the scan (subscribe with
+// `tn.sub({lex})` and watch), and the rule's close action finalizes the
+// block exactly as the engine-free `parse` tail does.
+const parser_1 = require("@tabnas/parser");
+const inline_ts_1 = require("./inline.js");
+const C_NEWLINE = 10;
+const C_BANG = 33;
+const C_AMPERSAND = 38;
+const C_ASTERISK = 42;
+const C_LESSTHAN = 60;
+const C_OPEN_BRACKET = 91;
+const C_BACKSLASH = 92;
+const C_CLOSE_BRACKET = 93;
+const C_UNDERSCORE = 95;
+const C_BACKTICK = 96;
+const C_TILDE = 126;
+/** The inline token alphabet, in the order the rule's alt lists them. */
+exports.INLINE_TOKENS = [
+    '#IBK', // line break (soft or hard, decided against the tree)
+    '#IES', // backslash escape
+    '#ICS', // code span (or an unmatched literal backtick run)
+    '#IDL', // emphasis/strikethrough delimiter run
+    '#IOB', // [
+    '#IBG', // ![
+    '#ICB', // ] — including a consumed inline link tail
+    '#IAL', // angle autolink
+    '#IHT', // raw HTML tag
+    '#IEN', // entity reference
+    '#ITX', // ordinary text run
+    '#ILI', // single literal character nothing else claimed
+];
+/**
+ * Adapt one `InlineParser` scanner method into a lexer matcher: sync the
+ * parser to the engine's point, run the method (which appends nodes and
+ * moves `pos`), and emit a token covering exactly what it consumed.
+ * `name` may depend on what was consumed (`!` vs `![`).
+ */
+function adapt(guard, run, name, opts) {
+    return (lex) => {
+        const st = lex.ctx && lex.ctx.u && lex.ctx.u.inl;
+        if (undefined === st)
+            return undefined;
+        const pnt = lex.pnt;
+        const src = lex.src;
+        if (pnt.sI >= src.length)
+            return undefined;
+        if (!guard(src.charCodeAt(pnt.sI), opts))
+            return undefined;
+        const p = st.parser;
+        const start = pnt.sI;
+        p.pos = start;
+        if (!run(p, st.block))
+            return undefined;
+        const consumed = src.slice(start, p.pos);
+        const tkn = lex.token(name(p, start), undefined, consumed, pnt);
+        // Row/column bookkeeping is observability data: a matcher that consumed
+        // line endings (soft breaks, multiline code spans or titles) moved the
+        // scan onto a later row, and later tokens must say so.
+        let newlines = 0;
+        let lastNl = -1;
+        for (let i = 0; i < consumed.length; i++) {
+            if (10 === consumed.charCodeAt(i)) {
+                newlines += 1;
+                lastNl = i;
+            }
+        }
+        if (0 < newlines) {
+            pnt.rI += newlines;
+            pnt.cI = consumed.length - lastNl;
+        }
+        else {
+            pnt.cI += consumed.length;
+        }
+        pnt.sI = p.pos;
+        return tkn;
+    };
+}
+/** Build the inline matcher set for one option set. GFM strikethrough is a
+ * separate matcher registered only when the option is on — the option
+ * reshapes the registered matcher set itself, so the base dialect's lexer
+ * simply has no tilde matcher rather than a disabled branch inside one. */
+function inlineMatchers(opts) {
+    const fixed = (n) => () => n;
+    const m = (order, guard, run, name) => ({ order, make: (() => adapt(guard, run, name, opts)) });
+    return {
+        inlBreak: m(1.00e5, (c) => C_NEWLINE === c, (p, b) => p.parseNewline(b), fixed('#IBK')),
+        inlEscape: m(1.01e5, (c) => C_BACKSLASH === c, (p, b) => p.parseBackslash(b), fixed('#IES')),
+        inlCode: m(1.02e5, (c) => C_BACKTICK === c, (p, b) => p.parseBackticks(b), fixed('#ICS')),
+        inlDelim: m(1.03e5, (c) => C_ASTERISK === c || C_UNDERSCORE === c, (p, b) => p.handleDelim(p.subject.charCodeAt(p.pos), b), fixed('#IDL')),
+        inlOpenBracket: m(1.04e5, (c) => C_OPEN_BRACKET === c, (p, b) => p.parseOpenBracket(b), fixed('#IOB')),
+        // `!` introduces an image only before `[`; otherwise it is a literal.
+        inlBang: m(1.05e5, (c) => C_BANG === c, (p, b) => p.parseBang(b), (p, start) => (2 === p.pos - start ? '#IBG' : '#ILI')),
+        // The cursor owner: on a successful inline link tail, `parseCloseBracket`
+        // has already consumed it when this token is emitted.
+        inlCloseBracket: m(1.06e5, (c) => C_CLOSE_BRACKET === c, (p, b) => p.parseCloseBracket(b), fixed('#ICB')),
+        // At `<`: autolink first, raw HTML second — matcher order is precedence.
+        inlAutolink: m(1.07e5, (c) => C_LESSTHAN === c, (p, b) => p.parseAutolink(b), fixed('#IAL')),
+        inlHtmlTag: m(1.08e5, (c) => C_LESSTHAN === c, (p, b) => p.parseHtmlTag(b), fixed('#IHT')),
+        inlEntity: m(1.09e5, (c) => C_AMPERSAND === c, (p, b) => p.parseEntity(b), fixed('#IEN')),
+        inlText: m(1.10e5, () => true, (p, b) => p.parseString(b), fixed('#ITX')),
+        // Nothing claimed the character: one literal char, same as the hand
+        // scanner's dispatch fallback.
+        inlLiteral: m(1.11e5, () => true, (p, b) => p.parseLiteralChar(b), fixed('#ILI')),
+        // GFM strikethrough: `~` runs join the delimiter stack only when the
+        // dialect is on (without it, the text matcher swallows tilde runs).
+        ...(true === opts.gfm
+            ? {
+                inlTilde: m(1.035e5, (c) => C_TILDE === c, (p, b) => p.handleDelim(C_TILDE, b), fixed('#IDL')),
+            }
+            : {}),
+    };
+}
+/**
+ * Build the package-private inline engine instance for one option set. All
+ * built-in matchers are disabled; the matcher set above is the complete
+ * lexical description of the inline phase.
+ */
+function makeInlineTn(opts) {
+    const tn = new parser_1.Tabnas();
+    tn.options({ rule: { start: 'inline' } });
+    // Human descriptions for the inline alphabet, surfaced in railroad
+    // diagram legends (read off the live config by @tabnas/railroad).
+    tn.options({
+        config: {
+            modify: {
+                'inl-tokendesc': (cfg) => {
+                    cfg.tokenDesc = Object.assign(cfg.tokenDesc || {}, {
+                        '#IBK': 'line break (soft or hard)',
+                        '#IES': 'backslash escape',
+                        '#ICS': 'code span',
+                        '#IDL': 'emphasis/strikethrough delimiter run',
+                        '#IOB': 'link opener [',
+                        '#IBG': 'image opener ![',
+                        '#ICB': 'closer ] (with any consumed inline link tail)',
+                        '#IAL': 'angle autolink',
+                        '#IHT': 'raw HTML tag',
+                        '#IEN': 'entity reference',
+                        '#ITX': 'text run',
+                        '#ILI': 'literal character',
+                    });
+                },
+            },
+        },
+    });
+    tn.options({
+        space: { lex: false },
+        line: { lex: false },
+        string: { lex: false },
+        comment: { lex: false },
+        number: { lex: false },
+        value: { lex: false },
+        text: { lex: false },
+        lex: { match: inlineMatchers(opts) },
+        parse: {
+            prepare: {
+                'inl-reset': (_tn, ctx, meta) => {
+                    ;
+                    ctx.u.inl =
+                        meta && meta.md ? { parser: meta.md.inl, block: meta.md.block } : undefined;
+                },
+            },
+        },
+    });
+    // One OR-position over the whole alphabet: any inline token loops the
+    // rule; the empty alts fall through to the close on #ZZ. The names are
+    // minted to tins here — the same table the matchers' lex.token calls use.
+    const toks = exports.INLINE_TOKENS.map((n) => tn.token(n));
+    tn.rule('inline', (rs) => {
+        return rs
+            .clear()
+            .open([{ s: [toks], r: 'inline' }, {}])
+            .close([
+            {
+                s: '#ZZ',
+                a: (_r, ctx) => {
+                    const st = ctx.u.inl;
+                    st.parser.finishBlock(st.block);
+                },
+            },
+            {},
+        ]);
+    });
+    return tn;
+}
+/**
+ * The engine-path inline phase: the same block walk as `parseInlines`, with
+ * each block's scan driven by the engine instance's lexer. An empty subject
+ * never reaches the engine (its empty-source path returns before the rules
+ * run), and finishes the block directly — a no-op resolve, exactly as the
+ * hand scanner's `parse` does.
+ */
+function parseInlinesEngine(inlineTn, doc, refmap, options) {
+    const parser = new inline_ts_1.InlineParser(refmap, options);
+    (0, inline_ts_1.forEachInlineBlock)(doc, options, (block) => {
+        if (!parser.beginBlock(block)) {
+            parser.finishBlock(block);
+            return;
+        }
+        inlineTn.parse(parser.subject, { md: { inl: parser, block } });
+    });
+}
+//# sourceMappingURL=engine-inline.js.map

package/dist/engine-inline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-inline.js","sourceRoot":"","sources":["../src/engine-inline.ts"],"names":[],"mappings":"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"}