parseman 0.7.1 → 0.9.0

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/combinators/first-set.ts", "../src/combinators/probe.ts", "../src/cst/capture-buffer.ts", "../src/combinators/literal.ts", "../src/combinators/regex.ts", "../src/combinators/keywords.ts", "../src/combinators/choice.ts", "../src/cst/trivia-kinds.ts", "../src/combinators/trivia-skip.ts", "../src/combinators/sequence.ts", "../src/combinators/repeat.ts", "../src/combinators/ref.ts", "../src/combinators/parser.ts", "../src/combinators/not.ts", "../src/combinators/node.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/compiler/trivia-fast-path.ts", "../src/compiler/inline-build.ts", "../src/compiler/inline-callback.ts", "../src/compiler/codegen.ts", "../src/combinators/guard.ts", "../src/combinators/withCtx.ts", "../src/combinators/recover.ts", "../src/combinators/completions.ts", "../src/combinators/scanTo.ts", "../src/functional/doc.ts", "../src/cst/trivia-index.ts", "../src/cst/trivia-entries.ts"],
-  "sourcesContent": ["import type { CharRange, FirstSet } from '../types.ts'\n\nexport function union(a: FirstSet, b: FirstSet): FirstSet {\n  if (a.kind === 'any' || b.kind === 'any') return { kind: 'any' }\n  if (a.kind === 'empty') return b\n  if (b.kind === 'empty') return a\n  return { kind: 'ranges', ranges: mergeRanges([...a.ranges, ...b.ranges]) }\n}\n\nexport function intersects(a: FirstSet, b: FirstSet): boolean {\n  if (a.kind === 'any' || b.kind === 'any') return true\n  if (a.kind === 'empty' || b.kind === 'empty') return false\n  for (const ra of a.ranges) {\n    for (const rb of b.ranges) {\n      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true\n    }\n  }\n  return false\n}\n\nexport function fromChar(code: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo: code, hi: code }] }\n}\n\nexport function fromRange(lo: number, hi: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo, hi }] }\n}\n\nexport function any(): FirstSet {\n  return { kind: 'any' }\n}\n\nexport function empty(): FirstSet {\n  return { kind: 'empty' }\n}\n\nfunction mergeRanges(ranges: CharRange[]): CharRange[] {\n  if (ranges.length === 0) return []\n  const sorted = [...ranges].sort((a, b) => a.lo - b.lo)\n  // Always copy \u2014 never alias input objects\n  const out: CharRange[] = [{ lo: sorted[0]!.lo, hi: sorted[0]!.hi }]\n  for (let i = 1; i < sorted.length; i++) {\n    const top = out[out.length - 1]!\n    const cur = sorted[i]!\n    if (cur.lo <= top.hi + 1) {\n      if (cur.hi > top.hi) top.hi = cur.hi\n    } else {\n      out.push({ lo: cur.lo, hi: cur.hi })\n    }\n  }\n  return out\n}\n", "import type { ParseContext, ParseFail } from '../types.ts'\n\n/**\n * Creates a ParseFail and, if a completions probe is active, records it.\n *\n * Rules:\n * - Only failures at or before the probe's target offset are eligible.\n * - A deeper failure (higher pos) replaces the current best.\n * - A tie (same pos) merges expected arrays \u2014 this is what makes choice arms\n *   aggregate their alternatives rather than each overwriting the last.\n * - Shallower failures are ignored.\n */\nexport function failAt(ctx: ParseContext, expected: string[], pos: number): ParseFail {\n  const r: ParseFail = { ok: false, expected, span: { start: pos, end: pos } }\n  const probe = ctx._probe\n  if (probe !== undefined && pos <= probe.offset) {\n    const best = probe.best\n    if (best === null || pos > best.span.start) {\n      probe.best = r\n    } else if (pos === best.span.start) {\n      probe.best = { ...best, expected: [...best.expected, ...expected] }\n    }\n  }\n  return r\n}\n", "import type { ParseContext } from '../types.ts'\n\n/** Lazy per-node capture state \u2014 arrays materialized on first push. */\nexport type CstCaptureBuf = {\n  single?: unknown | undefined\n  ch?: unknown[] | undefined\n  rawSingle?: unknown | undefined\n  raw?: unknown[] | undefined\n  tl?: number[] | undefined\n}\n\nconst EMPTY: unknown[] = []\nconst EMPTY_TL: number[] = []\n\nexport function cstCaptureActive(ctx: ParseContext): boolean {\n  return ctx._cstBuf !== undefined || ctx._cstLeaves !== undefined\n}\n\nexport type CstNodeCaptureSaved = {\n  ch: ParseContext['_cstChildren']\n  lv: ParseContext['_cstLeaves']\n  raw: ParseContext['_cstRawChildren']\n  tl: ParseContext['_cstTriviaLog']\n  cap: boolean | undefined\n  buf: CstCaptureBuf | undefined\n}\n\nexport function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {\n  const saved: CstNodeCaptureSaved = {\n    ch: ctx._cstChildren,\n    lv: ctx._cstLeaves,\n    raw: ctx._cstRawChildren,\n    tl: ctx._cstTriviaLog,\n    cap: ctx.captureTrivia,\n    buf: ctx._cstBuf,\n  }\n  ctx._cstBuf = {}\n  ctx._cstChildren = undefined\n  ctx._cstLeaves = undefined\n  ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined\n  ctx.captureTrivia = true\n  return saved\n}\n\nexport function finishCstBuf(buf: CstCaptureBuf | undefined): {\n  children: unknown[]\n  rawChildren: unknown[]\n  triviaLog: number[]\n} {\n  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL }\n  const children = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY)\n  const rawChildren = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY)\n  const triviaLog = buf.tl ?? EMPTY_TL\n  return { children, rawChildren, triviaLog }\n}\n\nexport function endCstNodeCapture(\n  ctx: ParseContext,\n  saved: CstNodeCaptureSaved,\n): { children: unknown[]; rawChildren: unknown[]; triviaLog: number[] } {\n  const materialized = finishCstBuf(ctx._cstBuf)\n  ctx._cstBuf = saved.buf\n  ctx._cstChildren = saved.ch\n  ctx._cstLeaves = saved.lv\n  ctx._cstRawChildren = saved.raw\n  ctx._cstTriviaLog = saved.tl\n  ctx.captureTrivia = saved.cap\n  return materialized\n}\n\nexport function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {\n  pushCstChild(ctx, leaf, leaf)\n}\n\n/** Record a built sub-node into the active collector (children vs rawChildren may differ). */\nexport function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) b.ch.push(built)\n    else if (b.single !== undefined) { b.ch = [b.single, built]; b.single = undefined }\n    else b.single = built\n\n    if (b.raw) b.raw.push(rawEntry)\n    else if (b.rawSingle !== undefined) { b.raw = [b.rawSingle, rawEntry]; b.rawSingle = undefined }\n    else b.rawSingle = rawEntry\n    return\n  }\n  if (ctx._cstChildren) ctx._cstChildren.push(built)\n  else if (ctx._cstLeaves) ctx._cstLeaves.push(built)\n  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)\n}\n\nexport function cstRawLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.raw) return b.raw.length\n    return b.rawSingle !== undefined ? 1 : 0\n  }\n  return ctx._cstRawChildren?.length ?? 0\n}\n\nexport function cstLeavesLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) return b.ch.length\n    return b.single !== undefined ? 1 : 0\n  }\n  return ctx._cstLeaves?.length ?? 0\n}\n\nexport function cstTlLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) return b.tl?.length ?? 0\n  return ctx._cstTriviaLog?.length ?? 0\n}\n\nexport type CstRollbackMark = { raw: number; tlog: number; leaves: number }\n\nexport function saveCstMark(ctx: ParseContext): CstRollbackMark {\n  return {\n    raw: cstRawLen(ctx),\n    tlog: cstTlLen(ctx),\n    leaves: cstLeavesLen(ctx),\n  }\n}\n\nfunction rollbackBufList(\n  b: CstCaptureBuf,\n  keyMulti: 'ch' | 'raw',\n  keySingle: 'single' | 'rawSingle',\n  len: number,\n): void {\n  const arr = b[keyMulti]\n  if (arr) {\n    if (len === 0) b[keyMulti] = undefined\n    else if (len === 1) { b[keySingle] = arr[0]; b[keyMulti] = undefined }\n    else arr.length = len\n    return\n  }\n  if (len === 0) b[keySingle] = undefined\n}\n\nexport function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void {\n  const b = ctx._cstBuf\n  if (b) {\n    rollbackBufList(b, 'raw', 'rawSingle', mark.raw)\n    rollbackBufList(b, 'ch', 'single', mark.leaves)\n    if (b.tl) {\n      if (mark.tlog === 0) b.tl = undefined\n      else b.tl.length = mark.tlog\n    }\n    return\n  }\n  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw\n  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog\n  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves\n}\n\nexport function pushCstTriviaEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  const insertIdx = cstRawLen(ctx)\n  const b = ctx._cstBuf\n  const withKind = ctx.triviaKindLabels !== undefined && kindIndex !== undefined\n  if (b) {\n    if (!b.tl) {\n      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx]\n    } else if (withKind) {\n      b.tl.push(start, end, insertIdx, kindIndex)\n    } else {\n      b.tl.push(start, end, insertIdx)\n    }\n    return\n  }\n  if (ctx._cstTriviaLog) {\n    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex)\n    else ctx._cstTriviaLog.push(start, end, insertIdx)\n  }\n}\n\nexport function pushTriviaLogEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  if (!ctx._triviaLog) return\n  if (ctx.triviaKindLabels !== undefined && kindIndex !== undefined) {\n    ctx._triviaLog.push(start, end, kindIndex)\n  } else {\n    ctx._triviaLog.push(start, end)\n  }\n}\n\nexport function cstDeferredTriviaActive(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { fromChar, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nlet _collatorCache: Intl.Collator | null = null\nfunction collator(): Intl.Collator {\n  if (_collatorCache === null) {\n    _collatorCache = new Intl.Collator(undefined, { sensitivity: 'accent' })\n  }\n  return _collatorCache\n}\n\nexport type LiteralOptions = {\n  caseInsensitive?: boolean\n}\n\nexport function literal(value: string, opts: LiteralOptions = {}): Combinator<string> {\n  const caseInsensitive = opts.caseInsensitive ?? false\n\n  const firstSet = value.length > 0\n    ? fromChar(value.codePointAt(0)!)\n    : empty()\n\n  const meta: ParserMeta = {\n    firstSet,\n    canMatchNewline: value.includes('\\n'),\n    isTrivia: false,\n  }\n\n  if (caseInsensitive) {\n    const upper = value.toUpperCase()\n    const lower = value.toLowerCase()\n    const firstUpper = upper.codePointAt(0)\n    const firstLower = lower.codePointAt(0)\n    meta.firstSet = firstLower !== undefined && firstUpper !== undefined\n      ? { kind: 'ranges', ranges: [\n          { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }\n        ]}\n      : firstSet\n  }\n\n  return {\n    _tag: 'literal',\n    _meta: meta,\n    _def: { tag: 'literal', value, caseInsensitive },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const end = pos + value.length\n      if (end > input.length) {\n        return failAt(ctx, [JSON.stringify(value)], pos)\n      }\n      const slice = input.slice(pos, end)\n      const matched = caseInsensitive\n        ? collator().compare(slice, value) === 0\n        : slice === value\n      if (matched) {\n        const span = { start: pos, end }\n        const leaf = { _tag: 'leaf', value: slice, span }\n        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n        return { ok: true, value: slice, span }\n      }\n      return failAt(ctx, [JSON.stringify(value)], pos)\n    },\n  }\n}\n", "import regexpTree from 'regexp-tree'\nimport type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { any, fromRange, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nfunction firstSetFromRegex(pattern: string): { firstSet: FirstSet; canMatchNewline: boolean } {\n  try {\n    const ast = regexpTree.parse(`/${pattern}/`)\n    return extractFirstSet(ast.body as unknown as RegexNode)\n  } catch {\n    return { firstSet: any(), canMatchNewline: true }\n  }\n}\n\ntype RegexNode = {\n  type: string\n  [key: string]: unknown\n}\n\nfunction canBeEmpty(node: RegexNode | null | undefined): boolean {\n  if (!node) return true\n  switch (node.type) {\n    case 'Repetition': {\n      const q = node.quantifier as { kind: string; from?: number }\n      return q.kind === '*' || q.kind === '?' || (q.kind === 'Range' && (q.from ?? 1) === 0)\n    }\n    case 'Alternative': {\n      const exprs = node.expressions as RegexNode[]\n      return !exprs || exprs.length === 0 || exprs.every(e => canBeEmpty(e))\n    }\n    case 'Group': return canBeEmpty(node.expression as RegexNode)\n    case 'Disjunction': return canBeEmpty(node.left as RegexNode) || canBeEmpty(node.right as RegexNode)\n    default: return false\n  }\n}\n\nfunction extractFirstSet(node: RegexNode | null | undefined): { firstSet: FirstSet; canMatchNewline: boolean } {\n  if (!node) return { firstSet: empty(), canMatchNewline: false }\n\n  switch (node.type) {\n    case 'Disjunction': {\n      const left = extractFirstSet(node.left as RegexNode)\n      const right = extractFirstSet(node.right as RegexNode)\n      return {\n        firstSet: union(left.firstSet, right.firstSet),\n        canMatchNewline: left.canMatchNewline || right.canMatchNewline,\n      }\n    }\n    case 'Alternative': {\n      const exprs = node.expressions as RegexNode[]\n      if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false }\n      // Walk forward through expressions that can match empty, unioning their first-sets.\n      // This handles patterns like -?[0-9]+ where the first expr is optional.\n      let fs: FirstSet = empty()\n      let canNL = false\n      for (const expr of exprs) {\n        const r = extractFirstSet(expr)\n        fs = union(fs, r.firstSet)\n        canNL = canNL || r.canMatchNewline\n        if (!canBeEmpty(expr)) break\n      }\n      return { firstSet: fs, canMatchNewline: canNL }\n    }\n    case 'Char': {\n      const kind = node.kind as string\n      if (kind === 'simple') {\n        const code = (node.codePoint as number | undefined) ?? (node.value as string).codePointAt(0) ?? 0\n        return { firstSet: fromRange(code, code), canMatchNewline: code === 0x0a }\n      }\n      if (kind === 'meta') {\n        const val = node.value as string\n        if (val === '.') return { firstSet: any(), canMatchNewline: false }\n        if (val === 'd') return { firstSet: fromRange(0x30, 0x39), canMatchNewline: false }\n        if (val === 'D') return { firstSet: any(), canMatchNewline: true }\n        if (val === 'w') return {\n          firstSet: union(union(fromRange(0x30, 0x39), fromRange(0x41, 0x5a)),\n            union(fromRange(0x61, 0x7a), fromRange(0x5f, 0x5f))),\n          canMatchNewline: false,\n        }\n        if (val === 's') return { firstSet: fromRange(0x09, 0x0d), canMatchNewline: true }\n        if (val === 'n') return { firstSet: fromRange(0x0a, 0x0a), canMatchNewline: true }\n      }\n      return { firstSet: any(), canMatchNewline: true }\n    }\n    case 'CharacterClass': {\n      const expressions = node.expressions as RegexNode[]\n      let fs: FirstSet = empty()\n      let canNL = false\n      for (const expr of expressions) {\n        if (expr.type === 'ClassRange') {\n          const from = (expr.from as RegexNode).codePoint as number\n          const to = (expr.to as RegexNode).codePoint as number\n          fs = union(fs, fromRange(from, to))\n          if (from <= 0x0a && 0x0a <= to) canNL = true\n        } else if (expr.type === 'Char') {\n          const r = extractFirstSet(expr)\n          fs = union(fs, r.firstSet)\n          canNL = canNL || r.canMatchNewline\n        }\n      }\n      if (node.negative) return { firstSet: any(), canMatchNewline: true }\n      return { firstSet: fs, canMatchNewline: canNL }\n    }\n    case 'Repetition': {\n      return extractFirstSet(node.expression as RegexNode)\n    }\n    case 'Group': {\n      return extractFirstSet(node.expression as RegexNode)\n    }\n    default:\n      return { firstSet: any(), canMatchNewline: true }\n  }\n}\n\nfunction optimizeRegex(source: string, flags: string): string {\n  try {\n    const result = regexpTree.optimize(`/${source}/${flags}`)\n    const str = result.toString()\n    const lastSlash = str.lastIndexOf('/')\n    return str.slice(1, lastSlash)\n  } catch {\n    return source\n  }\n}\n\nexport function regex(pattern: string | RegExp, flags = ''): Combinator<string> {\n  const source = typeof pattern === 'string' ? pattern : pattern.source\n  const resolvedFlags = typeof pattern === 'string' ? flags : pattern.flags\n\n  const optimizedSource = optimizeRegex(source, resolvedFlags)\n  const anchored = new RegExp(optimizedSource, 'y' + resolvedFlags.replace(/[gy]/g, ''))\n\n  const { firstSet, canMatchNewline } = firstSetFromRegex(source)\n  const meta: ParserMeta = { firstSet, canMatchNewline, isTrivia: false }\n\n  return {\n    _tag: 'regex',\n    _meta: meta,\n    _def: { tag: 'regex', source, flags: resolvedFlags, optimizedSource },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      anchored.lastIndex = pos\n      const m = anchored.exec(input)\n      if (m === null) {\n        return failAt(ctx, [`/${source}/`], pos)\n      }\n      const span = { start: pos, end: pos + m[0]!.length }\n      const leaf = { _tag: 'leaf', value: m[0]!, span }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n      return { ok: true, value: m[0]!, span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { fromChar, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type KeywordsOptions = {\n  /** Match case-insensitively. */\n  caseInsensitive?: boolean\n  /**\n   * Character class (regex source, e.g. `'A-Za-z0-9_-'`) that must NOT follow a\n   * match \u2014 a word boundary. Prevents matching `red` inside `redish`.\n   */\n  boundary?: string\n}\n\n/**\n * Match a single keyword with an automatic word-boundary guard. Prevents\n * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,\n * which covers most programming-language identifiers.\n *\n *   word('true')              // matches \"true\" but not \"trueish\"\n *   word('color', 'A-Za-z-') // CSS-style identifier boundary\n */\nexport function word(str: string, boundary = '_0-9A-Za-z'): Combinator<string> {\n  return keywords([str], { boundary })\n}\n\n/**\n * Create a keyword factory with a fixed word-boundary class. Use when many\n * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,\n * `word(str, boundary?)` is enough; you can also roll your own factory with\n * `(s) => word(s, boundary)`.\n *\n *   const kw = makeWord()                    // default: '_0-9A-Za-z'\n *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents\n *\n *   const query = kw('query')\n *   const color = cssKw('color')             // matches \"color\" but not \"color-scheme\"\n */\nexport function makeWord(boundary = '_0-9A-Za-z'): (str: string) => Combinator<string> {\n  return (str: string) => keywords([str], { boundary })\n}\n\nfunction escapeRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Match any one of a set of fixed keywords, longest-first (so `border` wins over\n * `bord`), with an optional trailing word-boundary guard. Compiles to a single\n * sticky regex \u2014 far less error-prone than a hand-maintained alternation, and\n * the common case (keyword sets: CSS colors, units, at-rule names, HTML tags).\n *\n *   keywords(CSS_COLOR_NAMES, { caseInsensitive: true, boundary: 'A-Za-z0-9_-' })\n *\n * On success the matched text is recorded as a CSTLeaf (like literal()/regex()).\n */\nexport function keywords(words: readonly string[], opts: KeywordsOptions = {}): Combinator<string> {\n  // Longest-first keeps the alternation greedy-correct (regex alternation is\n  // first-match, not longest-match).\n  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length)\n  const alt = sorted.map(escapeRe).join('|')\n  const boundary = opts.boundary ? `(?![${opts.boundary}])` : ''\n  const flags = opts.caseInsensitive ? 'iuy' : 'uy'\n  const re = new RegExp(`(?:${alt})${boundary}`, flags)\n\n  // First-set: the set of first code points across all keywords (and their\n  // case-folded variants when case-insensitive), for choice() dispatch.\n  let firstSet: FirstSet = empty()\n  for (const w of sorted) {\n    if (w.length === 0) continue\n    const cp = w.codePointAt(0)!\n    firstSet = union(firstSet, fromChar(cp))\n    if (opts.caseInsensitive) {\n      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0)\n      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0)\n      if (u !== undefined) firstSet = union(firstSet, fromChar(u))\n      if (l !== undefined) firstSet = union(firstSet, fromChar(l))\n    }\n  }\n\n  const meta: ParserMeta = { firstSet, canMatchNewline: false, isTrivia: false }\n\n  return {\n    _tag: 'keywords',\n    _meta: meta,\n    _def: { tag: 'keywords', words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      re.lastIndex = pos\n      const m = re.exec(input)\n      if (m === null || m.index !== pos) {\n        return failAt(ctx, ['keyword'], pos)\n      }\n      const value = m[0]!\n      const span = { start: pos, end: pos + value.length }\n      const leaf = { _tag: 'leaf', value, span }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n      return { ok: true, value, span }\n    },\n  }\n}\n", "import type {\n  Combinator, ParseContext, ParseResult, ParserMeta, FirstSet,\n  AutoNotCheck, CharRange, ChoiceStrategy, GatedArm,\n} from '../types.ts'\nimport { union, intersects } from './first-set.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\ntype ArmParser<T> = T extends GatedArm<infer U> ? Combinator<U> : T extends Combinator<infer U> ? Combinator<U> : never\ntype UnionArms<T extends (Combinator<unknown> | GatedArm<unknown>)[]> = {\n  [K in keyof T]: ArmParser<T[K]>\n}[number] extends Combinator<infer U> ? U : never\n\nexport function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(Combinator<unknown> | GatedArm<unknown>)[]]>(\n  ...args: T\n): Combinator<UnionArms<T>> {\n  // Unwrap gated arms into (parser, gate) pairs\n  const parsers = args.map(a => ('gate' in a ? a.combinator : a)) as Combinator<unknown>[]\n  const gates   = args.map(a => ('gate' in a ? a.gate   : null)) as (((state: unknown) => boolean) | null)[]\n\n  const hasGates = gates.some(g => g !== null)\n\n  const disjoint = !hasGates && areDisjoint(parsers.map(p => p._meta.firstSet))\n\n  let combined: FirstSet = { kind: 'empty' }\n  for (const p of parsers) combined = union(combined, p._meta.firstSet)\n\n  const meta: ParserMeta = {\n    firstSet: combined,\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n    disjoint,\n  }\n\n  // Gates force firstMatch \u2014 predicate dispatch is incompatible with first-set strategies.\n  const strategy = (disjoint || hasGates) ? null : detectStrategy(parsers)\n  const autoNot = (!disjoint && !hasGates && strategy?.tag === 'firstMatch')\n    ? computeAutoNot(parsers)\n    : parsers.map(() => null)\n\n  // Runtime state for each strategy (built once, reused on every parse call):\n  let greedyRe: RegExp | null = null\n  let greedyLitMap: Map<string, number> | null = null\n  let sortedParsers: Combinator<unknown>[] | null = null\n\n  if (strategy?.tag === 'greedyClassify') {\n    const regexDef = getCoreRegexDef(parsers[strategy.superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    greedyRe = new RegExp(regexDef.source, flags)\n    greedyLitMap = new Map()\n    for (let i = 0; i < parsers.length; i++) {\n      if (i === strategy.superIndex) continue\n      const litVal = getCoreLiteralValue(parsers[i]!)\n      if (litVal !== null) greedyLitMap.set(litVal, i)\n    }\n  } else if (strategy?.tag === 'literalsLongestFirst') {\n    sortedParsers = strategy.sortedIndices.map(i => parsers[i]!)\n  }\n\n  return {\n    _tag: 'choice',\n    _meta: meta,\n    _def: {\n      tag: 'choice',\n      parsers,\n      gates,\n      disjoint,\n      strategy: strategy ?? { tag: 'firstMatch' },\n      autoNot,\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnionArms<T>> {\n      const expected: string[] = []\n\n      // \u2500\u2500 Disjoint: O(1) first-char dispatch (never has gates) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      if (disjoint && pos < input.length) {\n        const code = input.codePointAt(pos)!\n        for (const parser of parsers) {\n          if (inFirstSet(code, parser._meta.firstSet)) {\n            const result = parser.parse(input, pos, ctx)\n            if (result.ok) return result as ParseResult<UnionArms<T>>\n            expected.push(...result.expected)\n            return { ok: false, expected, span: { start: pos, end: pos } }\n          }\n        }\n        return {\n          ok: false,\n          expected: parsers.flatMap(p => {\n            const r = p.parse(input, pos, ctx)\n            return r.ok ? [] : r.expected\n          }),\n          span: { start: pos, end: pos },\n        }\n      }\n\n      // \u2500\u2500 greedyClassify: run one regex, classify by string equality \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //    One parse call total. No backtracking.\n      if (strategy?.tag === 'greedyClassify') {\n        const superResult = parsers[strategy.superIndex]!.parse(input, pos, ctx)\n        if (!superResult.ok) return superResult as ParseResult<UnionArms<T>>\n\n        const end = superResult.span.end\n        const litIdx = greedyLitMap!.get(input.slice(pos, end))\n        if (litIdx !== undefined) {\n          const litVal = getCoreLiteralValue(parsers[litIdx]!)!\n          const value = applyTransforms(parsers[litIdx]!, litVal, { start: pos, end })\n          return { ok: true, value: value as UnionArms<T>, span: { start: pos, end } }\n        }\n        return superResult as ParseResult<UnionArms<T>>\n      }\n\n      // \u2500\u2500 literalsLongestFirst: sorted descending by length, no backtracking \u2500\n      if (strategy?.tag === 'literalsLongestFirst') {\n        for (const p of sortedParsers!) {\n          const r = p.parse(input, pos, ctx)\n          if (r.ok) return r as ParseResult<UnionArms<T>>\n          expected.push(...r.expected)\n        }\n        return { ok: false, expected, span: { start: pos, end: pos } }\n      }\n\n      // \u2500\u2500 firstMatch (+ gated arms): try each arm in order, skipping gated-off arms \u2500\u2500\n      for (let i = 0; i < parsers.length; i++) {\n        if (gates[i] && !gates[i]!(ctx.state)) continue   // gate blocks this arm\n        // Save leaf-array lengths so a failed/rejected arm can be rolled back.\n        const mark = saveCstMark(ctx)\n        const logLen = ctx._triviaLog?.length\n        const result = parsers[i]!.parse(input, pos, ctx)\n        if (!result.ok) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          expected.push(...result.expected)\n          continue\n        }\n        const checks = autoNot[i]\n        if (checks && autoNotFires(input, result.span.end, checks)) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          continue\n        }\n        return result as ParseResult<UnionArms<T>>\n      }\n      return { ok: false, expected, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Strategy detection\n// ---------------------------------------------------------------------------\n\nfunction detectStrategy(parsers: Combinator<unknown>[]): ChoiceStrategy {\n  // greedyClassify: exactly one regex arm whose regex matches every literal arm's\n  // value exactly (and can potentially match more). All other arms must be literals.\n  const regexIndices: number[] = []\n  const literalIndices: number[] = []\n  for (let i = 0; i < parsers.length; i++) {\n    if (getCoreRegexDef(parsers[i]!) !== null) regexIndices.push(i)\n    else if (getCoreLiteralValue(parsers[i]!) !== null) literalIndices.push(i)\n  }\n\n  if (\n    regexIndices.length === 1 &&\n    literalIndices.length === parsers.length - 1 &&\n    literalIndices.length > 0\n  ) {\n    const superIndex = regexIndices[0]!\n    const regexDef = getCoreRegexDef(parsers[superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    const re = new RegExp(regexDef.source, flags)\n    const allSubsumed = literalIndices.every(i => {\n      const litVal = getCoreLiteralValue(parsers[i]!)!\n      re.lastIndex = 0\n      const m = re.exec(litVal)\n      return m !== null && m[0] === litVal\n    })\n    if (allSubsumed) return { tag: 'greedyClassify', superIndex }\n  }\n\n  // literalsLongestFirst: every arm is a literal \u2014 try longest first, no backtracking\n  if (parsers.length === literalIndices.length) {\n    const sortedIndices = [...literalIndices].sort((a, b) =>\n      getCoreLiteralValue(parsers[b]!)!.length - getCoreLiteralValue(parsers[a]!)!.length\n    )\n    return { tag: 'literalsLongestFirst', sortedIndices }\n  }\n\n  return { tag: 'firstMatch' }\n}\n\n// ---------------------------------------------------------------------------\n// Auto-not analysis (firstMatch fallback only)\n// ---------------------------------------------------------------------------\n\nfunction computeAutoNot(parsers: Combinator<unknown>[]): (AutoNotCheck[] | null)[] {\n  return parsers.map((p, i) => {\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) return null\n\n    const checks: AutoNotCheck[] = []\n    for (let j = i + 1; j < parsers.length; j++) {\n      const other = parsers[j]!\n      const otherLit = getCoreLiteralValue(other)\n      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {\n        checks.push({ kind: 'startsWith', value: otherLit.slice(litVal.length) })\n        continue\n      }\n      const regexDef = getCoreRegexDef(other)\n      if (regexDef !== null) {\n        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags)\n        if (contSet !== null) checks.push({ kind: 'firstSet', set: contSet })\n      }\n    }\n    return checks.length > 0 ? checks : null\n  })\n}\n\nfunction autoNotFires(input: string, end: number, checks: AutoNotCheck[]): boolean {\n  for (const check of checks) {\n    if (check.kind === 'firstSet') {\n      const code = end < input.length ? (input.codePointAt(end) ?? -1) : -1\n      if (inFirstSet(code, check.set)) return true\n    } else {\n      if (input.startsWith(check.value, end)) return true\n    }\n  }\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// Helpers: unwrap transform/sequence wrappers\n// ---------------------------------------------------------------------------\n\n/** Walk transform wrappers to find an inner literal's string value. */\nexport function getCoreLiteralValue(p: Combinator<unknown>): string | null {\n  const def = p._def\n  if (def.tag === 'literal' && !def.caseInsensitive) return def.value\n  if (def.tag === 'transform') return getCoreLiteralValue(def.parser)\n  return null\n}\n\n/** Walk transform wrappers to find an inner regex's source/flags. */\nexport function getCoreRegexDef(p: Combinator<unknown>): { source: string; flags: string } | null {\n  const def = p._def\n  if (def.tag === 'regex') return { source: def.source, flags: def.flags }\n  if (def.tag === 'transform') return getCoreRegexDef(def.parser)\n  if (def.tag === 'label') return getCoreRegexDef(def.parser)\n  return null\n}\n\n/**\n * Apply a parser's transform chain to an already-known value, without re-parsing.\n * Used by greedyClassify to avoid a second parse call for the winning literal arm.\n */\nfunction applyTransforms(p: Combinator<unknown>, value: unknown, span: { start: number; end: number }): unknown {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const inner = applyTransforms(def.parser, value, span)\n    return def.fn(inner, span)\n  }\n  return value\n}\n\n// ---------------------------------------------------------------------------\n// Continuation first-set (for firstMatch auto-not analysis)\n// ---------------------------------------------------------------------------\n\nfunction continuationFirstSet(lit: string, source: string, flags: string): FirstSet | null {\n  const re = new RegExp(source, 'y' + flags.replace(/[gy]/g, ''))\n  re.lastIndex = 0\n  const base = re.exec(lit)\n  if (!base || base[0] !== lit) return null\n\n  const contCodes: number[] = []\n  for (let code = 1; code < 128; code++) {\n    re.lastIndex = 0\n    const m = re.exec(lit + String.fromCharCode(code))\n    if (m && m[0].length > lit.length) contCodes.push(code)\n  }\n  if (contCodes.length === 0) return null\n  return codesToFirstSet(contCodes)\n}\n\nfunction codesToFirstSet(codes: number[]): FirstSet {\n  codes.sort((a, b) => a - b)\n  const ranges: CharRange[] = []\n  let lo = codes[0]!, hi = codes[0]!\n  for (let i = 1; i < codes.length; i++) {\n    if (codes[i] === hi + 1) { hi = codes[i]! }\n    else { ranges.push({ lo, hi }); lo = hi = codes[i]! }\n  }\n  ranges.push({ lo, hi })\n  return { kind: 'ranges', ranges }\n}\n\nfunction inFirstSet(code: number, fs: FirstSet): boolean {\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nfunction areDisjoint(sets: FirstSet[]): boolean {\n  if (sets.some(s => s.kind === 'any')) return false\n  for (let i = 0; i < sets.length; i++)\n    for (let j = i + 1; j < sets.length; j++)\n      if (intersects(sets[i]!, sets[j]!)) return false\n  return true\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport { pushCstTriviaEntry, pushTriviaLogEntry } from './capture-buffer.ts'\n\nexport type TriviaChunk = { start: number; end: number; kindIndex: number }\n\nexport type LabeledTriviaSpec = {\n  readonly labels: readonly string[]\n  readonly arms: ReadonlyArray<{ label: string; kindIndex: number; parser: Combinator<unknown> }>\n  readonly minRepeats: number\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\n/** Strip `label()` wrapper; returns inner parser for matching. */\nexport function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {\n  if (p._def.tag === 'label') return { label: p._def.label, parser: p._def.parser }\n  return null\n}\n\n/**\n * When every trivia arm is `label(name, parser)` inside `oneOrMore(choice(\u2026))`\n * (or a single labeled arm), return the label table and matchers.\n */\nexport function analyzeLabeledTrivia(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  let core = unwrapTrivia(trivia)\n  let minRepeats = 1\n\n  if (core._def.tag === 'oneOrMore') {\n    core = core._def.parser\n    minRepeats = 1\n  } else if (core._def.tag === 'many') {\n    core = core._def.parser\n    minRepeats = 0\n  }\n\n  const arms: LabeledTriviaSpec['arms'][number][] = []\n\n  if (core._def.tag === 'choice') {\n    for (let i = 0; i < core._def.parsers.length; i++) {\n      const peeled = peelLabel(core._def.parsers[i]!)\n      if (!peeled) return null\n      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser })\n    }\n  } else {\n    const peeled = peelLabel(core)\n    if (!peeled) return null\n    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser })\n  }\n\n  return { labels: arms.map(a => a.label), arms, minRepeats }\n}\n\n/** Label table on a `trivia()` combinator, if all arms are labeled. */\nexport function triviaKindLabels(trivia: Combinator<unknown> | undefined): readonly string[] | undefined {\n  if (!trivia) return undefined\n  const fromMeta = trivia._meta.triviaKindLabels\n  if (fromMeta) return fromMeta\n  return analyzeLabeledTrivia(trivia)?.labels\n}\n\nfunction matchArmAt(\n  input: string,\n  pos: number,\n  arm: Combinator<unknown>,\n): { end: number } | null {\n  const r = arm.parse(input, pos, { trackLines: false })\n  if (!r.ok || r.span.end <= pos) return null\n  return { end: r.span.end }\n}\n\n/**\n * Scan maximal labeled trivia chunks (PEG `oneOrMore(choice(\u2026))` semantics).\n * Each successful arm match becomes one entry with that arm's kind index.\n */\nexport function scanLabeledTriviaChunks(\n  input: string,\n  cur: number,\n  spec: LabeledTriviaSpec,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    let matched: { end: number; kindIndex: number } | null = null\n    for (const arm of spec.arms) {\n      const m = matchArmAt(input, pos, arm.parser)\n      if (m) {\n        matched = { end: m.end, kindIndex: arm.kindIndex }\n        break\n      }\n    }\n    if (!matched) break\n    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex })\n    pos = matched.end\n  }\n\n  if (chunks.length < spec.minRepeats) {\n    return { end: cur, chunks: [] }\n  }\n  return { end: pos, chunks }\n}\n\n/** Hand-rolled ws / block-comment scan with per-chunk kind indices (interpreter). */\nexport function scanFastWsCommentsChunks(\n  input: string,\n  cur: number,\n  wsKind: number,\n  commentKind: number,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    const c = input.charCodeAt(pos)\n    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {\n      const start = pos\n      pos++\n      while (pos < input.length) {\n        const c2 = input.charCodeAt(pos)\n        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++\n        else break\n      }\n      chunks.push({ start, end: pos, kindIndex: wsKind })\n      continue\n    }\n    if (c === 47 && input.charCodeAt(pos + 1) === 42) {\n      const start = pos\n      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      pos = j + 2 <= input.length ? j + 2 : input.length\n      chunks.push({ start, end: pos, kindIndex: commentKind })\n      continue\n    }\n    break\n  }\n\n  return { end: pos, chunks }\n}\n\n/** Fast scan when trivia is labeled ws + block-comment (CSS `rw`). */\nexport function tryFastLabeledScan(\n  input: string,\n  cur: number,\n  trivia: Combinator<unknown>,\n): { end: number; chunks: TriviaChunk[] } | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec || spec.arms.length !== 2) return null\n\n  const wsArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && !src.includes('\\\\*')\n  })\n  const commentArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && src.includes('\\\\*')\n  })\n  if (!wsArm || !commentArm) return null\n\n  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] }\n  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n}\n\nexport function recordTriviaChunks(ctx: ParseContext, chunks: readonly TriviaChunk[]): void {\n  const kinds = ctx.triviaKindLabels\n  for (const ch of chunks) {\n    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    if (ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)) {\n      pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    }\n  }\n}\n", "import type { ParseContext } from '../types.ts'\nimport {\n  analyzeLabeledTrivia,\n  recordTriviaChunks,\n  scanLabeledTriviaChunks,\n  tryFastLabeledScan,\n} from '../cst/trivia-kinds.ts'\nimport {\n  pushCstTriviaEntry,\n  pushTriviaLogEntry,\n  rollbackCstCapture,\n  saveCstMark,\n} from '../cst/capture-buffer.ts'\n\n/**\n * Result of scanning trivia: the position after it, plus a `commit()` that\n * records the matched trivia tokens into the active rawChildren collector.\n * Recording is deferred so callers that may reject the following item (e.g.\n * many()/oneOrMore() retries) can advance speculatively without recording\n * trivia that doesn't actually sit between two accepted items.\n */\nexport type TriviaScan = { end: number; commit: () => void }\n\n/** Saved lengths for rolling back speculative trivia commits. */\nexport type TriviaRollbackMark = { raw: number; tlog: number; leaves: number; log: number }\n\nconst NOOP_COMMIT = () => {}\n\n/** True when trivia recording must be deferred until the following term commits. */\nexport function needsDeferredTriviaCommit(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n\nexport function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark {\n  const m = saveCstMark(ctx)\n  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, log: ctx._triviaLog ? ctx._triviaLog.length : 0 }\n}\n\nexport function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void {\n  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves })\n  if (ctx._triviaLog) ctx._triviaLog.length = mark.log\n}\n\nfunction scanWithLabels(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia!\n  const spec = analyzeLabeledTrivia(triviaP)\n  if (!spec) return { end: cur, commit: NOOP_COMMIT }\n\n  const fast = tryFastLabeledScan(input, cur, triviaP)\n  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec)\n  if (end === cur) return { end: cur, commit: NOOP_COMMIT }\n\n  return {\n    end,\n    commit: () => recordTriviaChunks(ctx, chunks),\n  }\n}\n\n/**\n * Skip trivia at `cur` and return the new position. No recording, no wrapper\n * object \u2014 use between sequence/repeat terms when CST trivia capture is off.\n */\nexport function advanceTrivia(input: string, cur: number, ctx: ParseContext): number {\n  const triviaP = ctx.trivia\n  if (!triviaP) return cur\n  if (ctx.triviaKindLabels) {\n    const scan = scanWithLabels(input, cur, ctx)\n    return scan.end\n  }\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return tr.ok && tr.span.end > cur ? tr.span.end : cur\n}\n\n/**\n * Scan trivia at `cur` using `ctx.trivia`, WITHOUT recording it. Returns the\n * position after the trivia (or `cur` if none) and a `commit()` to record it.\n */\nexport function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia\n  if (!triviaP) return { end: cur, commit: NOOP_COMMIT }\n\n  const log = ctx._triviaLog\n  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)\n\n  if (ctx.triviaKindLabels && (log !== undefined || captureTl)) {\n    return scanWithLabels(input, cur, ctx)\n  }\n\n  if (log !== undefined || captureTl) {\n    const tr = triviaP.parse(input, cur, {\n      trackLines: log !== undefined ? false : ctx.trackLines,\n      state: ctx.state,\n    })\n    if (!tr.ok || tr.span.end === cur) return { end: cur, commit: NOOP_COMMIT }\n    const end = tr.span.end\n    return {\n      end,\n      commit: () => {\n        pushTriviaLogEntry(ctx, cur, end)\n        if (captureTl) pushCstTriviaEntry(ctx, cur, end)\n      },\n    }\n  }\n\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT }\n}\n\n/**\n * Consume trivia at `cur`, recording it immediately. For callers that always\n * accept the trivia between two committed terms (e.g. sequence/sepBy).\n */\nexport function consumeTrivia(input: string, cur: number, ctx: ParseContext): number {\n  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx)\n  const scan = scanTrivia(input, cur, ctx)\n  scan.commit()\n  return scan.end\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'\nimport { empty } from './first-set.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\n\ntype UnwrapParsers<T extends Combinator<unknown>[]> = {\n  [K in keyof T]: T[K] extends Combinator<infer U> ? U : never\n}\n\nexport function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[]]>(\n  ...parsers: T\n): Combinator<UnwrapParsers<T>> {\n  const meta: ParserMeta = {\n    firstSet: parsers[0]?._meta.firstSet ?? empty(),\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'sequence',\n    _meta: meta,\n    _def: { tag: 'sequence', parsers: parsers as Combinator<unknown>[] },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n      const values: unknown[] = []\n      let cur = pos\n\n      for (let i = 0; i < parsers.length; i++) {\n        if (ctx.trivia && i > 0) {\n          // Skip trivia between terms, but only *consume* it for span purposes if\n          // this term actually matches content past the trivia. A term that matches\n          // empty (optional/many/lookahead) leaves the trivia for the enclosing rule.\n          let scanEnd: number\n          let mark = saveTriviaMark(ctx)\n\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) {\n            cur = result.span.end\n          } else {\n            rollbackTrivia(ctx, mark)\n          }\n          values.push(result.value)\n          continue\n        }\n\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        values.push(result.value)\n        cur = result.span.end\n      }\n\n      return {\n        ok: true,\n        value: values as UnwrapParsers<T>,\n        span: { start: pos, end: cur },\n      }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\n\n/**\n * Parse one repetition item at `cur`, first skipping (and, in capture mode,\n * recording) any leading trivia \u2014 so a repeating combinator consumes the trivia\n * between items uniformly, the way advancing the index always should. Trivia is\n * committed *before* the item so rawChildren order stays [item, trivia, item];\n * if the item then fails or makes no progress the trivia is rolled back and the\n * loop stops (the trivia is trailing and belongs to the enclosing context).\n *\n * Returns the item value + end position, the underlying failure (so oneOrMore\n * can propagate a first-item failure), or 'stop'.\n */\nfunction repItem<T>(\n  combinator: Combinator<T>,\n  input: string,\n  cur: number,\n  ctx: ParseContext\n): { value: T; end: number } | { fail: ParseResult<T> } | 'stop' {\n  const mark = saveTriviaMark(ctx)\n  let pos = cur\n  if (ctx.trivia) {\n    if (needsDeferredTriviaCommit(ctx)) {\n      const scan = scanTrivia(input, cur, ctx)\n      scan.commit()\n      pos = scan.end\n    } else {\n      pos = advanceTrivia(input, cur, ctx)\n    }\n  }\n  // Nothing but trivia left: don't speculatively parse an item at EOF (it would\n  // fail and could trigger an item's recover()/error side-effects). The trivia\n  // is trailing \u2014 roll it back for the enclosing context and stop.\n  if (pos >= input.length) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  const result = combinator.parse(input, pos, ctx)\n  if (!result.ok) {\n    rollbackTrivia(ctx, mark)\n    return { fail: result }\n  }\n  if (result.span.end === pos) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  return { value: result.value, end: result.span.end }\n}\n\nexport function many<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'many',\n    _meta: meta,\n    _def: { tag: 'many', parser: combinator as Combinator<unknown>, min: 0 },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const values: T[] = []\n      let cur = pos\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop' || 'fail' in item) break\n        values.push(item.value)\n        cur = item.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'oneOrMore',\n    _meta: meta,\n    _def: { tag: 'oneOrMore', parser: combinator as Combinator<unknown>, min: 1 },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // First item is mandatory (parsed at pos directly \u2014 leading trivia is the\n      // enclosing context's responsibility); subsequent items skip leading trivia.\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return first\n      const values: T[] = [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop' || 'fail' in item) break\n        values.push(item.value)\n        cur = item.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function optional<T>(combinator: Combinator<T>): Combinator<T | null> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'optional',\n    _meta: meta,\n    _def: { tag: 'optional', parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {\n      const mark = saveTriviaMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T>\n      // Inner failed \u2192 roll back any CST leaves/trivia it captured before giving up.\n      rollbackTrivia(ctx, mark)\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n\nexport function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'sepBy',\n    _meta: meta,\n    _def: { tag: 'sepBy', parser: combinator as Combinator<unknown>, separator: separator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return { ok: true, value: [], span: { start: pos, end: pos } }\n      const values: T[] = [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        // One mark for the whole iteration (separator + following item): if the\n        // item fails, the trailing separator must be rolled back with it, or its\n        // captured leaves leak past the end of the list.\n        const loopMark = saveTriviaMark(ctx)\n        let sepPos = cur\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            sepPos = scan.end\n          } else {\n            sepPos = advanceTrivia(input, cur, ctx)\n          }\n        }\n        const sep = separator.parse(input, sepPos, ctx)\n        if (!sep.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        let nextPos = sep.span.end\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, sep.span.end, ctx)\n            scan.commit()\n            nextPos = scan.end\n          } else {\n            nextPos = advanceTrivia(input, sep.span.end, ctx)\n          }\n        }\n        const next = combinator.parse(input, nextPos, ctx)\n        if (!next.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        values.push(next.value)\n        cur = next.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Create a forward-declared parser slot for mutually recursive grammars.\n *\n * Because JS evaluates arguments eagerly, you can't reference a variable\n * before it's declared. ref() creates a placeholder you fill in later:\n *\n *   const value = ref<JSONValue>()\n *   const array  = transform(sequence(literal('['), sepBy(value, literal(',')), literal(']')), ...)\n *   const object = transform(sequence(literal('{'), sepBy(pair, literal(',')), literal('}')), ...)\n *   value.define(choice(object, array, string, number, bool, nullVal))\n *\n * Unlike lazy(() => x), you use the ref directly \u2014 no wrapping at each call site.\n */\nexport function ref<T>(): Combinator<T> & { define(p: Combinator<T>): void } {\n  let resolved: Combinator<T> | null = null\n\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  const slot = {\n    _tag: 'lazy' as const,\n    _meta: meta,\n    _def: {\n      tag: 'lazy' as const,\n      thunk: () => {\n        if (!resolved) throw new Error('ref<T>() used before .define() was called')\n        return resolved as Combinator<unknown>\n      },\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      if (!resolved) throw new Error('ref<T>() used before .define() was called')\n      return resolved.parse(input, pos, ctx)\n    },\n    define(p: Combinator<T>): void {\n      if (resolved) throw new Error('ref<T>() already defined')\n      resolved = p\n    },\n  }\n\n  return slot\n}\n", "import type { Combinator } from '../types.ts'\nimport { ref } from './ref.ts'\n\n/**\n * Define named grammar rules without forward declarations.\n *\n * Pass a factory that receives all rule names as references (via a Proxy)\n * and returns a record of combinators. rules() handles creating ref()\n * placeholders and wiring them up \u2014 the user never sees ref() at all.\n *\n *   const { value } = rules(g => ({\n *     value:  choice(g.object, g.array, str, num, bool, nil),\n *     object: transform(sequence('{', sepBy(g.pair, ','), '}'), Object.fromEntries),\n *     array:  transform(sequence('[', sepBy(g.value, ','), ']'), ([, items]) => items),\n *     pair:   transform(sequence(g.key, literal(':'), g.value), ([k,, v]) => [k, v]),\n *   }))\n *\n * Not every name in the factory must appear in the returned object \u2014 local helpers\n * (like `comma`, `key`) can be plain const inside the factory and composed normally.\n * Only names that OTHER rules reference via `g.xxx` need to be in the returned record.\n *\n * TypeScript: use an explicit type parameter for full type safety on `g`:\n *   rules<{ value: Combinator<JSONValue>; array: Combinator<JSONValue[]> }>(g => ({ ... }))\n * Without it, `g.*` accesses are typed as `any` but the return is still inferred.\n */\nexport function rules<T extends Record<string, Combinator<unknown>>>(\n  factory: (self: any) => T\n): T {\n  const cache: Partial<T> = {}\n\n  // Proxy: accessing any property creates a ref() placeholder on first touch.\n  const proxy = new Proxy(cache, {\n    get(target, key) {\n      if (typeof key !== 'string') return undefined\n      const record = target as Record<string, Combinator<unknown>>\n      if (!(key in record)) {\n        record[key] = ref()\n      }\n      return record[key]\n    },\n  })\n\n  // Evaluate all rule definitions. JavaScript evaluates object-literal values\n  // left-to-right, so any `g.ruleName` access inside triggers placeholder creation\n  // before the rule's own parser is built \u2014 enabling forward references.\n  const definitions = factory(proxy)\n\n  // Fill each ref with its actual definition, or store directly if never accessed via proxy.\n  for (const key of Object.keys(definitions)) {\n    const placeholder = (cache as Record<string, Combinator<unknown>>)[key]\n    const parser = (definitions as Record<string, Combinator<unknown>>)[key]!\n    if (placeholder !== undefined && typeof (placeholder as any).define === 'function') {\n      ;(placeholder as any).define(parser)\n      // Propagate actual first-set so later choices wrapping this ref get correct dispatch.\n      placeholder._meta.firstSet = parser._meta.firstSet\n      placeholder._meta.canMatchNewline = parser._meta.canMatchNewline\n    } else {\n      ;(cache as Record<string, Combinator<unknown>>)[key] = parser\n    }\n  }\n\n  return cache as T\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Negative lookahead. Succeeds (consuming nothing) when `combinator` fails;\n * fails when `combinator` succeeds.\n *\n * The standard way to match a keyword without also matching the prefix\n * of a longer identifier:\n *\n *   const kwTrue = sequence(literal('true'), not(regex(/\\w/)))\n *   // matches \"true\" in \"true && x\" but NOT in \"trueish\" or \"trueness\"\n */\nexport function not(combinator: Combinator<unknown>): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: any(),     // we don't know what NOT matches\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'not',\n    _meta: meta,\n    _def: { tag: 'not', parser: combinator },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) {\n        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } }\n      }\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\n\n/**\n * A CST/AST node rule. Runs `combinator` while collecting its terminals into\n * `children` / `rawChildren` arrays and trivia spans into `triviaLog`, then\n * calls `build(children, rawChildren, span, triviaLog)` to produce the node.\n *\n *   - `children`    \u2014 structural items in source order: spanned CSTLeaf terminals\n *                     and sub-nodes (whatever `build` returned for inner nodes).\n *   - `rawChildren` \u2014 structural children only (same items as `children`).\n *   - `triviaLog`   \u2014 flat log of trivia entries: each entry is `[start, end, insertIdx]`\n *                     consumed between terms. `insertIdx` is the rawChildren index\n *                     before which the trivia was consumed. Use `buildTriviaIndex`\n *                     to turn this into a before/after lookup table.\n *\n * If `build` returns a non-node value (e.g. a bare string for a collapsed rule),\n * the parent records it as a spanned leaf so its source span is still recoverable.\n */\nexport type BuildNode<N> = (\n  children: ReadonlyArray<unknown>,\n  rawChildren: ReadonlyArray<unknown>,\n  span: { start: number; end: number },\n  triviaLog: readonly number[],\n  state: unknown,\n) => N\n\nexport function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>): Combinator<N> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: { tag: 'node', type, parser: combinator, build },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      const r = combinator.parse(input, pos, ctx)\n      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved)\n\n      if (!r.ok) return r\n\n      const state = ctx.state !== undefined\n        ? Object.assign({}, ctx.state as Record<string, unknown>)\n        : undefined\n      const built = build(children, rawChildren, r.span, triviaLog, state)\n      const isNodeLike = typeof built === 'object' && built !== null && (built as { _tag?: string })._tag === 'node'\n      const rawEntry = isNodeLike\n        ? built\n        : { _tag: 'leaf', value: typeof built === 'string' ? built : '', span: r.span }\n      if (saved.buf !== undefined || saved.ch !== undefined) {\n        pushCstChild(ctx, built, rawEntry)\n      }\n      return { ok: true, value: built, span: r.span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\n\nexport function transform<T, U>(\n  combinator: Combinator<T>,\n  fn: (value: T, span: { start: number; end: number }) => U\n): Combinator<U> {\n  return {\n    _tag: 'transform',\n    _meta: combinator._meta,\n    _def: { tag: 'transform', parser: combinator as Combinator<unknown>, fn: fn as (v: unknown, span: { start: number; end: number }) => unknown },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<U> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      return { ...result, value: fn(result.value, result.span) }\n    },\n  }\n}\n\nexport function skip<T, S>(main: Combinator<T>, skipped: Combinator<S>): Combinator<T> {\n  return {\n    _tag: 'skip',\n    _meta: main._meta,\n    _def: { tag: 'skip', main: main as Combinator<unknown>, skipped: skipped as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = main.parse(input, pos, ctx)\n      if (!result.ok) return result\n      const s = skipped.parse(input, result.span.end, ctx)\n      if (!s.ok) return result\n      return { ...result, span: { start: result.span.start, end: s.span.end } }\n    },\n  }\n}\n\nexport function trivia<T>(combinator: Combinator<T>): Combinator<T> {\n  const kindLabels = analyzeLabeledTrivia(combinator as Combinator<unknown>)?.labels\n  return {\n    _tag: combinator._tag,\n    _meta: {\n      ...combinator._meta,\n      isTrivia: true,\n      ...(kindLabels ? { triviaKindLabels: kindLabels } : {}),\n    },\n    _def: { tag: 'trivia', parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n\n/**\n * Attach a string label to a parser arm (e.g. trivia `choice` branches).\n * Parse behavior is unchanged; the label is metadata for tooling and future\n * trivia-kind capture (`'whitespace'`, `'blockComment'`, \u2026).\n */\nexport function label<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'label', label: name, parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset\u2192line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { buildLineIndex, annotateSpan } from '../compiler/line-index.ts'\n\nexport type ParseOptions = {\n  trackLines?: boolean\n  /**\n   * Enable error recovery. When true, recover() nodes collect their ParseErrors\n   * into a side-channel array rather than (only) embedding them in the value tree.\n   * The returned ParseOk will have an `errors` field listing all recovered errors.\n   * Top-level parse failures (where no recover() node caught the error) still\n   * return ParseFail as usual.\n   */\n  recover?: boolean\n}\n\nexport type ParserOptions = ParseOptions & {\n  /**\n   * Trivia parser for this scope. Three states:\n   *   - a Combinator \u2192 skip this trivia between sequence/repeat terms\n   *   - `undefined`  \u2192 inherit the enclosing scope's trivia (no change)\n   *   - `null`       \u2192 CLEAR trivia: no trivia skipped, so terms must be contiguous.\n   *                    Re-enable inside a nested region with another parser({ trivia }).\n   */\n  trivia?: Combinator<unknown> | null\n  /** Record consumed trivia as CSTTrivia tokens in rawChildren. Default: skip. */\n  captureTrivia?: boolean\n}\n\nexport interface ParsemanParser<T> extends Combinator<T> {\n  parse(input: string): ParseResult<T>\n  parse(input: string, pos: number, ctx: ParseContext): ParseResult<T>\n}\n\nexport function parser<T>(opts: ParserOptions, root: Combinator<T>): ParsemanParser<T> {\n  const clearTrivia = opts.trivia === null\n  return {\n    _tag: 'grammar',\n    _meta: root._meta,\n    _def: {\n      tag: 'grammar',\n      parser: root as Combinator<unknown>,\n      triviaParser: clearTrivia ? undefined : (opts.trivia ?? undefined),\n      clearTrivia,\n      trackLines: opts.trackLines ?? false,\n    },\n    parse(input: string, pos?: number, _ctx?: ParseContext): ParseResult<T> {\n      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false\n      // Preserve any CST collectors / capture flag from the caller (e.g. an\n      // enclosing node()), layering this grammar's trivia on top. Without this,\n      // a parser() nested inside a node() would drop the node's child collectors.\n      const ctx: ParseContext = {\n        ..._ctx,\n        trackLines,\n        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.\n        ...(clearTrivia ? {\n          trivia: undefined,\n          triviaKindLabels: undefined,\n        } : opts.trivia != null ? {\n          trivia: opts.trivia,\n          ...(opts.trivia._meta.triviaKindLabels\n            ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels }\n            : {}),\n        } : {}),\n        ...(opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}),\n      }\n      const result = root.parse(input, pos ?? 0, ctx)\n      if (trackLines) {\n        const idx = buildLineIndex(input)\n        return { ...result, span: annotateSpan(result.span, idx) }\n      }\n      return result\n    },\n  } as ParsemanParser<T>\n}\n\n/**\n * Run `root` with the active trivia cleared \u2014 no trivia is skipped between its\n * sequence/repeat terms, so they must be contiguous in the input. (Trivia is\n * whatever parser({ trivia }) installed \u2014 often whitespace/comments, but it is\n * grammar-defined.) The inverse of parser({ trivia }); re-enable trivia in a\n * nested region with another parser({ trivia }).\n *\n * Wrap the WHOLE contiguous run: an enclosing sequence skips trivia *before* a\n * term runs, so wrapping just the inner part would let leading trivia through.\n *\n * For a static glued token just use one literal/regex; reach for noTrivia when a\n * glued part is a structured sub-rule \u2014 e.g. a head glued to a `[subscript]`\n * whose interior still allows trivia. Turn trivia back on for a region by nesting\n * another parser({ trivia }) (innermost wins, reverts on exit); put the WHOLE\n * spaced region \u2014 including its leading `[` \u2014 inside it, since sequence skips\n * trivia only between terms, not before its first:\n *\n *   // `arr[i + 1]` \u2014 `arr` touches `[`, but the subscript is a spaced expr:\n *   noTrivia(sequence(name,\n *     parser({ trivia: ws }, sequence(literal('['), expr, literal(']')))))\n */\nexport function noTrivia<T>(root: Combinator<T>): ParsemanParser<T> {\n  return parser({ trivia: null }, root)\n}\n\nexport function parse<T>(\n  combinator: Combinator<T>,\n  input: string,\n  opts: ParseOptions = {}\n): ParseResult<T> {\n  const trackLines = opts.trackLines ?? false\n  const _errors = opts.recover ? [] : undefined\n  const ctx: ParseContext = {\n    trackLines,\n    ...(_errors !== undefined ? { _errors } : {}),\n  }\n  const result = combinator.parse(input, 0, ctx)\n  if (!result.ok) return result\n  const withErrors = _errors !== undefined ? { ...result, errors: _errors } : result\n  if (trackLines) {\n    const idx = buildLineIndex(input)\n    return { ...withErrors, span: annotateSpan(withErrors.span, idx) }\n  }\n  return withErrors\n}\n", "import type { Combinator } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\n\nexport type TriviaFastKind = 'wsComments' | 'wsOnly'\n\nconst BLOCK_COMMENT = String.raw`\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/`\n\n/** Regex sources for ASCII whitespace runs (incl. regexp-tree reorderings). */\nconst WS_CLASS_SOURCES = new Set([\n  String.raw`[ \\t\\n\\r\\f]+`,\n  String.raw`[ \\t\\n]+`,\n  String.raw`[ \\t]+`,\n  String.raw`[\\t\\n\\f\\r ]+`,\n])\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\nfunction oneOrMoreInner(p: Combinator<unknown>): Combinator<unknown> | null {\n  const d = p._def\n  if (d.tag === 'oneOrMore') return d.parser\n  if (d.tag === 'many' && d.min >= 1) return d.parser\n  return null\n}\n\nfunction choiceArms(p: Combinator<unknown>): Combinator<unknown>[] | null {\n  if (p._def.tag === 'choice') return p._def.parsers\n  return null\n}\n\nfunction isWsClassSource(source: string): boolean {\n  return WS_CLASS_SOURCES.has(source)\n}\n\nfunction isBlockCommentSource(source: string): boolean {\n  return source === BLOCK_COMMENT\n}\n\n/**\n * Detect trivia shapes safe to lower to a hand-rolled scan loop in compiled output.\n * Matches CSS `rw` (`oneOrMore(choice(ws, blockComment))`) and ASCII ws-only grammars.\n * Single alternation regexes are excluded \u2014 one regex exec matches only one arm per call.\n */\nexport function analyzeTriviaFastPath(trivia: Combinator<unknown>): TriviaFastKind | null {\n  const core = unwrapTrivia(trivia)\n\n  const direct = getCoreRegexDef(core)?.source\n  if (direct) {\n    if (isWsClassSource(direct)) return 'wsOnly'\n    return null\n  }\n\n  const inner = oneOrMoreInner(core)\n  if (!inner) return null\n\n  const innerSrc = getCoreRegexDef(inner)?.source\n  if (innerSrc && isWsClassSource(innerSrc)) return 'wsOnly'\n\n  const arms = choiceArms(inner)\n  if (!arms || arms.length !== 2) return null\n\n  let hasWs = false\n  let hasComment = false\n  for (const arm of arms) {\n    const src = getCoreRegexDef(arm)?.source\n    if (!src) return null\n    if (isWsClassSource(src)) hasWs = true\n    else if (isBlockCommentSource(src)) hasComment = true\n    else return null\n  }\n  if (hasWs && hasComment) return 'wsComments'\n  return null\n}\n\nconst CAP_RECORD = [\n  `  if (_cap && _e > _pos) {`,\n  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n  `  }`,\n].join('\\n')\n\nconst WS_ONLY_LOOP = [\n  `  while (_e < input.length) {`,\n  `    const c = input.charCodeAt(_e)`,\n  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,\n  `    break`,\n  `  }`,\n].join('\\n')\n\nconst WS_COMMENTS_LOOP = [\n  `  while (_e < input.length) {`,\n  `    const c = input.charCodeAt(_e)`,\n  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,\n  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,\n  `      let j = _e + 2`,\n  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,\n  `      _e = j + 2 <= input.length ? j + 2 : input.length`,\n  `      continue`,\n  `    }`,\n  `    break`,\n  `  }`,\n].join('\\n')\n\nconst CAP_CHUNK = (wsKind: number, commentKind: number) => [\n  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {`,\n  `      const _cs = _e`,\n  `      _e++`,\n  `      while (_e < input.length) {`,\n  `        const c2 = input.charCodeAt(_e)`,\n  `        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) _e++`,\n  `        else break`,\n  `      }`,\n  `      if (_cap) {`,\n  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${wsKind})`,\n  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${wsKind})`,\n  `      }`,\n  `      continue`,\n  `    }`,\n  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,\n  `      const _cs = _e`,\n  `      let j = _e + 2`,\n  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,\n  `      _e = j + 2 <= input.length ? j + 2 : input.length`,\n  `      if (_cap) {`,\n  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${commentKind})`,\n  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${commentKind})`,\n  `      }`,\n  `      continue`,\n  `    }`,\n].join('\\n')\n\nconst WS_COMMENTS_LOOP_LABELED = (wsKind: number, commentKind: number) => [\n  `  while (_e < input.length) {`,\n  `    const c = input.charCodeAt(_e)`,\n  CAP_CHUNK(wsKind, commentKind),\n  `    break`,\n  `  }`,\n].join('\\n')\n\n/** Emit a specialized `_tfN` that skips trivia without regex / combinator dispatch. */\nexport function buildFastTriviaFnDecl(\n  fnName: string,\n  kind: TriviaFastKind,\n  kindIndices?: { ws: number; comment: number },\n): string {\n  const loop = kind === 'wsComments' && kindIndices\n    ? WS_COMMENTS_LOOP_LABELED(kindIndices.ws, kindIndices.comment)\n    : kind === 'wsComments'\n      ? WS_COMMENTS_LOOP\n      : WS_ONLY_LOOP\n  const cap = kindIndices ? '' : CAP_RECORD\n  const lines = [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    loop,\n  ]\n  if (cap) lines.push(cap)\n  lines.push(`  return _e`, `}`)\n  return lines.join('\\n')\n}\n\nfunction regexArmIndex(spec: LabeledTriviaSpec, isComment: boolean): number | null {\n  for (const arm of spec.arms) {\n    const src = getCoreRegexDef(arm.parser)?.source\n    if (!src) return null\n    const comment = src.includes('\\\\*') || src.startsWith('\\\\/\\\\/')\n    if (comment === isComment) return arm.kindIndex\n  }\n  return null\n}\n\n/** Labeled trivia with regex arms \u2014 per-chunk kind capture in compiled output. */\nexport function buildLabeledRegexTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  reNames: string[],\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const re = reNames[i]!\n    const k = arm.kindIndex\n    return [\n      `    ${re}.lastIndex = _e`,\n      `    const _m${i} = ${re}.exec(input)`,\n      `    if (_m${i} && _m${i}.index === _e) {`,\n      `      const _ce = _e + _m${i}[0].length`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\nexport function labeledTriviaKindIndices(trivia: Combinator<unknown>): { ws: number; comment: number } | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec || spec.arms.length !== 2) return null\n  const ws = regexArmIndex(spec, false)\n  const comment = regexArmIndex(spec, true)\n  if (ws === null || comment === null) return null\n  return { ws, comment }\n}\n\nexport function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  for (const arm of spec.arms) {\n    if (!getCoreRegexDef(arm.parser)) return null\n  }\n  return spec\n}\n\n/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */\nexport function buildLabeledRuntimeTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  rpStartIndex: number,\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const k = arm.kindIndex\n    const ri = rpStartIndex + i\n    return [\n      `    const _r${i} = _rp[${ri}].parse(input, _e, _ctx)`,\n      `    if (_r${i}.ok && _r${i}.span.end > _e) {`,\n      `      const _ce = _r${i}.span.end`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n", "import type { ParserDef } from '../types.ts'\n\n/** `(c, r, s, tl) => mk('Type', c, r, s, tl)` \u2014 CSS perf regression builder shape. */\nconst MK_BUILD_RE =\n  /^\\(\\s*(?:\\w+\\s*,\\s*){3}\\w+\\s*\\)\\s*=>\\s*mk\\s*\\(\\s*(['\"])([^'\"]+)\\1\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*\\)\\s*$/\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Any callee \u2014 covers `mk`, `import_x.mk`, `__vite_ssr_import_0__.mk`, etc. */\nfunction looseMkBuildRe(type: string): RegExp {\n  return new RegExp(\n    String.raw`^\\(\\s*(?:\\w+\\s*,\\s*){3}\\w+\\s*\\)\\s*=>\\s*.+\\(\\s*(['\"])${escapeRegExp(type)}\\1\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*\\)\\s*$`,\n  )\n}\n\n/**\n * When a node() build is a thin `mk(type, \u2026)` wrapper, emit the object literal\n * at the call site instead of `_build[n](\u2026)`.\n */\nexport function analyzeMkInlineBuild(def: Extract<ParserDef, { tag: 'node' }>): string | null {\n  const src = (def.buildSrc ?? def.build.toString()).trim()\n  const strict = src.match(MK_BUILD_RE)\n  if (strict) {\n    const mkType = strict[2]!\n    return mkType === def.type ? def.type : null\n  }\n  if (looseMkBuildRe(def.type).test(src)) return def.type\n  return null\n}\n\n/** Object literal matching `stub-build.ts` `mk()` without the function call. */\nexport function emitInlineMkNodeExpr(\n  type: string,\n  chV: string,\n  rawV: string,\n  pos: string,\n  endVar: string,\n  tlV: string,\n): string {\n  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`\n}\n", "/** Builtins allowed in inlined transform bodies (not treated as free closure refs). */\nconst INLINE_BUILTINS = new Set([\n  'parseInt', 'parseFloat', 'String', 'Number', 'Boolean', 'Object', 'Array', 'Math', 'JSON',\n  'undefined', 'null', 'true', 'false', 'NaN', 'Infinity',\n])\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Source text for a transform callback \u2014 macro `fnSrc` or arrow `toString()`. */\nexport function transformFnSource(fn: Function, fnSrc?: string | null): string | null {\n  if (fnSrc) return fnSrc.trim()\n  const s = fn.toString().trim()\n  if (s.includes('[native code]')) return null\n  return s\n}\n\nfunction replaceParam(body: string, param: string, valueVar: string): string {\n  return body.replace(new RegExp(`\\\\b${escapeRegExp(param)}\\\\b`, 'g'), valueVar)\n}\n\nfunction stripForIdCheck(body: string): string {\n  return body\n    .replace(/'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"/g, '\"\"')\n    .replace(/\\bas\\s+const\\b/g, '')\n    .replace(/\\b[A-Za-z_$][\\w$]*\\s*:/g, ':')\n}\n\nfunction hasFreeIdentifiers(body: string, allowed: ReadonlySet<string>): boolean {\n  const stripped = stripForIdCheck(body)\n  const ids = stripped.match(/\\b[A-Za-z_$][\\w$]*\\b/g) ?? []\n  for (const id of ids) {\n    if (INLINE_BUILTINS.has(id)) continue\n    if (allowed.has(id)) continue\n    return true\n  }\n  return false\n}\n\n/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */\nexport function tryInlineUnaryTransform(src: string, valueVar: string): string | null {\n  const allowed = new Set([valueVar])\n  const nullary = src.match(/^\\(\\s*\\)\\s*=>\\s*(.+)$/)\n  if (nullary) {\n    const body = nullary[1]!.trim()\n    return hasFreeIdentifiers(body, allowed) ? null : body\n  }\n  const m = src.match(/^(\\w+)\\s*=>\\s*(.+)$/)\n  if (!m) return null\n  const body = replaceParam(m[2]!.trim(), m[1]!, valueVar)\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n\n/** Parse `[a, , c]` destructuring slots (null = ignore). */\nexport function parseArrayDestructure(pattern: string, arity: number): (string | null)[] {\n  const slots: (string | null)[] = []\n  for (const part of pattern.split(',')) {\n    const name = part.trim()\n    slots.push(name === '' || name === '_' ? null : name)\n  }\n  while (slots.length < arity) slots.push(null)\n  return slots.slice(0, arity)\n}\n\n/**\n * `([x, y]) => body` \u2014 substitute destructure names with sequence value vars.\n * Caller must ensure body only references slotted params (+ builtins).\n */\nexport function tryInlineDestructureTransform(\n  src: string,\n  valueVars: string[],\n): string | null {\n  const m = src.match(/^\\(\\s*\\[([^\\]]*)\\]\\s*\\)\\s*=>\\s*(.+)$/s)\n  if (!m) return null\n  const slots = parseArrayDestructure(m[1]!, valueVars.length)\n  let body = m[2]!.trim()\n  const allowed = new Set(valueVars)\n  for (let i = 0; i < slots.length; i++) {\n    const name = slots[i]\n    if (name) body = replaceParam(body, name, valueVars[i]!)\n  }\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n", "/**\n * Compile a Combinator<T> definition tree into an optimized JavaScript function.\n *\n * Design: every sub-emitter uses early-return on failure. Fallible contexts\n * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a\n * `break <label>` rather than an IIFE return \u2014 no function call, no result\n * object allocation per node.\n */\nimport type { Combinator, ParserDef, FirstSet, ParseResult, ParseContext, ParseError, ChoiceStrategy } from '../types.ts'\nimport { getCoreLiteralValue, getCoreRegexDef } from '../combinators/choice.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport {\n  analyzeTriviaFastPath,\n  buildFastTriviaFnDecl,\n  buildLabeledRegexTriviaFnDecl,\n  buildLabeledRuntimeTriviaFnDecl,\n  labeledTriviaKindIndices,\n  labeledTriviaRegexArms,\n} from './trivia-fast-path.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport {\n  transformFnSource,\n  tryInlineUnaryTransform,\n  tryInlineDestructureTransform,\n} from './inline-callback.ts'\n\n// ---------------------------------------------------------------------------\n// Codegen context\n// ---------------------------------------------------------------------------\ntype Ctx = {\n  vars: number\n  indent: number\n  /** Regex declarations hoisted to module scope */\n  regexDecls: string[]\n  /** Dedup map: \"source/flags\" \u2192 variable name (_re0 etc.) */\n  regexMap: Map<string, string>\n  /** Map functions that need to be captured at compile time */\n  mapFns: Array<(v: unknown, span: { start: number; end: number }) => unknown>\n  /**\n   * Source text of each map function, captured in lockstep with `mapFns`\n   * (parallel array). Populated from `def.fnSrc` when present \u2014 lets the macro\n   * inline transform callbacks in codegen-traversal order without a fragile\n   * pre-accumulated positional array. `null` entries mean the source was not\n   * available (interpreter/compile() path with no macro source).\n   */\n  mapFnSrcs: Array<string | null>\n  /** Runtime parser fallbacks (for unknown/_def-less parsers) */\n  runtimeParsers: Array<Combinator<unknown>>\n  /** Whether any case-insensitive lit was emitted (needs collator) */\n  needsCollator: boolean\n  /** Lazy/ref parsers and trivia helpers: parser identity \u2192 generated function name */\n  namedParsers: Map<Combinator<unknown>, string>\n  /** Generated function declaration strings, prepended before the main body */\n  namedFnDecls: string[]\n  /** Active trivia parser (set by grammar() wrappers, cleared on exit) */\n  activeTrivia?: Combinator<unknown> | undefined\n  /** Label table from grammar trivia for default ParseContext. */\n  triviaKindLabels?: readonly string[] | undefined\n  /**\n   * Whether this compile contains any node() rule. When true, terminals emit a\n   * `_ctx._cstLeaves` capture and trivia skips capture trivia tokens \u2014 flowing\n   * through `_ctx` so capture crosses named-function (ref) boundaries correctly.\n   * When false (no node() anywhere) NO capture code is emitted, so non-CST\n   * grammars compile byte-identically to before.\n   */\n  capturing?: boolean\n  /** Inside the trivia-capture fn: terminals emit CSTTrivia tokens, not leaves. */\n  capAsTrivia?: boolean | undefined\n  /** Trivia parser \u2192 name of its capturing variant fn (separate from namedParsers). */\n  triviaCaptureNames: Map<Combinator<unknown>, string>\n  /**\n   * Trivia parser \u2192 name of its fast number-returning variant fn (non-capturing\n   * mode). Returns the new position directly instead of a {ok,value,span} object,\n   * eliminating two object allocations per trivia skip.\n   */\n  triviaFnNames: Map<Combinator<unknown>, string>\n  /** node() build functions captured at compile time (parallel to buildSrcs). */\n  buildFns: Array<(children: ReadonlyArray<unknown>, raw: ReadonlyArray<unknown>, span: { start: number; end: number }, triviaLog: readonly number[], state: unknown) => unknown>\n  /** Source text of each build fn (set from def.buildSrc; null when unavailable). */\n  buildSrcs: Array<string | null>\n  /**\n   * When set, `failStmt` emits `break <label>` instead of `return { ok: false }`.\n   * Used by emitFallible to let labeled blocks act as the failure boundary.\n   */\n  failLabel?: string | undefined\n}\n\nfunction v(ctx: Ctx, prefix = '_v'): string { return `${prefix}${ctx.vars++}` }\nfunction ind(ctx: Ctx): string { return '  '.repeat(ctx.indent) }\n\n/** Re-indent emitted lines to an absolute depth while preserving relative nesting. */\nfunction reindentStmts(stmts: string[], targetLevels: number): string[] {\n  const nonEmpty = stmts.filter(s => s.trim().length > 0)\n  if (nonEmpty.length === 0) return stmts\n  const minLeading = Math.min(...nonEmpty.map(s => s.length - s.trimStart().length))\n  const targetPrefix = '  '.repeat(targetLevels)\n  return stmts.map(s => (s.trim().length === 0 ? '' : targetPrefix + s.slice(minLeading)))\n}\n\nfunction failReturn(expected: string, posExpr: string): string {\n  return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failReturnArr(expectedArr: string, posExpr: string): string {\n  return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return failReturn(expected, posExpr)\n}\n\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string): string {\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return failReturnArr(expectedArr, posExpr)\n}\n\nfunction emitIfFail(ctx: Ctx, cond: string, body: string): string[] {\n  return [\n    `${ind(ctx)}if (${cond}) {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\nfunction emitElseFail(ctx: Ctx, body: string): string[] {\n  return [\n    `${ind(ctx)}else {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\n/** Sentinel + end-position slot for compiled `rules()` / `withCtx` named fns. */\nconst NAMED_FN_FAIL = '_pfFail'\nconst NAMED_FN_END = '_pfEnd'\n\nfunction namedFnPrelude(): string[] {\n  return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`]\n}\n\nfunction pushNamedFnDecl(\n  ctx: Ctx,\n  fnName: string,\n  bodyStmts: string[],\n  valueVar: string,\n  endVar: string,\n): void {\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx) {`,\n    `  let _pfok = false, _pfv, _pfe = _pos`,\n    `  _pfail: {`,\n    ...reindentStmts(bodyStmts, 2),\n    `    _pfv = ${valueVar}`,\n    `    _pfe = ${endVar}`,\n    `    _pfok = true`,\n    `  }`,\n    `  if (!_pfok) return ${NAMED_FN_FAIL}`,\n    `  ${NAMED_FN_END} = _pfe`,\n    `  return _pfv`,\n    `}`,\n  ].join('\\n'))\n}\n\nfunction emitNamedFnCall(ctx: Ctx, fnName: string, pos: string, failExpected: string): ER {\n  const vv = v(ctx, '_pfv')\n  const ev = v(ctx, '_pfe')\n  return {\n    stmts: [\n      `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, failExpected, pos)),\n      `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n    ],\n    valueVar: vv,\n    endVar: ev,\n  }\n}\n\n/**\n * Emit a spanned-leaf capture into the active node()'s collectors (via _ctx,\n * matching the interpreter). Emitted only in a capturing compile; the runtime\n * `if (_ctx._cstLeaves)` guard means terminals outside a node() pay one\n * predictable branch and nothing else.\n */\nfunction emitLeafCapture(ctx: Ctx, valExpr: string, startExpr: string, endExpr: string): string[] {\n  if (!ctx.capturing) return []\n  if (ctx.capAsTrivia) return []\n  const i = ind(ctx)\n  const lf = v(ctx, '_lf')\n  return [\n    `${i}if (_ctx._cstLeaves) {`,\n    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,\n    `${i}  _ctx._cstLeaves.push(${lf})`,\n    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,\n    `${i}}`,\n  ]\n}\n\nfunction ensureRegexDecl(ctx: Ctx, optimizedSource: string, flags: string): string {\n  const f = 'y' + flags.replace(/[gy]/g, '')\n  const key = `${optimizedSource}/${f}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${optimizedSource}/${f}`)\n    ctx.regexMap.set(key, rName)\n  }\n  return rName\n}\n\n/**\n * When `cap` is truthy, also records `[start, end]` (and optional insertIdx) into\n * `_ctx._triviaLog` / `_ctx._cstTriviaLog`. One emitted function serves both skip\n * and capture call sites \u2014 no duplicate trivia parser tree, no _tc wrapper call.\n */\nfunction ensureTriviaFn(ctx: Ctx): string {\n  const trivia = ctx.activeTrivia!\n  const existing = ctx.triviaFnNames.get(trivia)\n  if (existing) return existing\n  const fnName = `_tf${ctx.triviaFnNames.size}`\n  ctx.triviaFnNames.set(trivia, fnName)\n  ctx.triviaCaptureNames.set(trivia, fnName)\n\n  const fastKind = analyzeTriviaFastPath(trivia)\n  const kindIndices = labeledTriviaKindIndices(trivia)\n  if (fastKind) {\n    ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastKind, kindIndices ?? undefined))\n    return fnName\n  }\n\n  const labeledSpec = analyzeLabeledTrivia(trivia)\n  if (labeledSpec) {\n    const regexSpec = labeledTriviaRegexArms(trivia)\n    if (regexSpec) {\n      const reNames: string[] = []\n      for (const arm of regexSpec.arms) {\n        const def = arm.parser._def\n        if (def.tag !== 'regex') break\n        reNames.push(ensureRegexDecl(ctx, def.optimizedSource, def.flags))\n      }\n      if (reNames.length === regexSpec.arms.length) {\n        ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames))\n        return fnName\n      }\n    }\n\n    const rpStart = ctx.runtimeParsers.length\n    for (const arm of labeledSpec.arms) {\n      ctx.runtimeParsers.push(arm.parser)\n    }\n    ctx.namedFnDecls.push(buildLabeledRuntimeTriviaFnDecl(fnName, labeledSpec, rpStart))\n    return fnName\n  }\n\n  const savedIndent    = ctx.indent\n  const savedFailLabel = ctx.failLabel\n  const savedTrivia    = ctx.activeTrivia\n  const savedCapAsTrivia = ctx.capAsTrivia\n  ctx.indent    = 2\n  ctx.failLabel = '_triv'\n  ctx.capAsTrivia = true  // trivia terminals must not push into _cstLeaves\n  ctx.activeTrivia = undefined  // trivia parser must not skip trivia within itself\n  const r = emit(trivia, ctx, '_pos')\n  ctx.indent    = savedIndent\n  ctx.failLabel = savedFailLabel\n  ctx.capAsTrivia = savedCapAsTrivia\n  ctx.activeTrivia = savedTrivia\n\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  _triv: {`,\n    ...reindentStmts(r.stmts, 2),\n    `    _e = ${r.endVar}`,\n    `  }`,\n    `  if (_cap && _e > _pos) {`,\n    `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n    `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n'))\n  return fnName\n}\n\n/** Capturing trivia skip \u2014 same compiled fn as ensureTriviaFn, pass `_cap = 1`. */\nfunction ensureTriviaCaptureFn(ctx: Ctx): string {\n  return ensureTriviaFn(ctx)\n}\n\n// ---------------------------------------------------------------------------\n// The result every emitter returns.\n// After the emitted stmts, `valueVar` holds the parsed value and `endVar`\n// holds the new position. On failure the emitter already emitted an early\n// `return failResult`.\n// ---------------------------------------------------------------------------\ntype ER = { stmts: string[]; valueVar: string; endVar: string }\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\nfunction firstSetCond(codeVar: string, fs: FirstSet): string {\n  if (fs.kind === 'any') return 'true'\n  if (fs.kind === 'empty') return 'false'\n  return fs.ranges.map(r =>\n    r.lo === r.hi\n      ? `${codeVar} === ${r.lo}`\n      : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`\n  ).join(' || ')\n}\n\n/** Wrap stmts + success return in an IIFE. Returns the IIFE expression string. */\nfunction asIIFE(stmts: string[], valueVar: string, endVar: string, startPos: string, indent: string): string {\n  return [\n    `(() => {`,\n    ...stmts,\n    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,\n    `${indent}})()`,\n  ].join('\\n')\n}\n\n/**\n * Emit `inner` as a labeled block with flat result variables \u2014 no IIFE call,\n * no `{ ok, value, span }` object allocation.  The returned stmts declare:\n *   let ${okVar} = false, ${valVar}, ${endVar} = ${pos}\n *   ${label}: { <inner stmts using break ${label} on failure>; capture success }\n * Callers read ${okVar} to branch on success/failure.\n */\nfunction emitFallible(\n  inner: Combinator<unknown>,\n  ctx: Ctx,\n  pos: string,\n): { stmts: string[]; okVar: string; valVar: string; endVar: string } {\n  const lbl  = v(ctx, '_lbl')\n  const okV  = `${lbl}ok`\n  const valV = `${lbl}v`\n  const endV = `${lbl}e`\n\n  const savedLabel  = ctx.failLabel\n  const savedIndent = ctx.indent\n  ctx.failLabel = lbl\n  ctx.indent    = savedIndent + 1\n  const r = emit(inner, ctx, pos)\n  ctx.failLabel = savedLabel\n  ctx.indent    = savedIndent\n\n  const ind0 = ind(ctx)\n  // In capturing mode, roll back any CST captures made by a FAILED attempt \u2014 a\n  // sub-parser may match terminals (e.g. a sequence that consumes '[') and then\n  // fail on a later term, breaking out with those leaves/trivia still buffered.\n  // Without this they leak into the enclosing node()'s children. (The non-disjoint\n  // choice path does the same per-arm; a disjoint choice commits to one arm and\n  // relies on this boundary to undo a failed commit.)\n  const mL  = ctx.capturing ? v(ctx, '_fcl')  : null\n  const mR  = ctx.capturing ? v(ctx, '_fcr')  : null\n  const mTl = ctx.capturing ? v(ctx, '_fctl') : null\n  const mLg = ctx.capturing ? v(ctx, '_fclg') : null\n  const stmts = [\n    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,\n    ...(mL ? [\n      `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,\n      `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,\n      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,\n      `${ind0}const ${mLg} = _ctx._triviaLog?.length ?? 0`,\n    ] : []),\n    `${ind0}${lbl}: {`,\n    ...r.stmts,\n    `${ind0}  ${valV} = ${r.valueVar}`,\n    `${ind0}  ${endV} = ${r.endVar}`,\n    `${ind0}  ${okV} = true`,\n    `${ind0}}`,\n    ...(mL ? [\n      `${ind0}if (!${okV}) { if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg} }`,\n    ] : []),\n  ]\n  return { stmts, okVar: okV, valVar: valV, endVar: endV }\n}\n\n\n// ---------------------------------------------------------------------------\n// Per-combinator emitters\n// ---------------------------------------------------------------------------\n\nfunction emitLit(def: Extract<ParserDef, { tag: 'literal' }>, ctx: Ctx, pos: string): ER {\n  const { value, caseInsensitive } = def\n  const len = value.length\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(JSON.stringify(value))\n  const stmts: string[] = []\n\n  if (caseInsensitive) {\n    ctx.needsCollator = true\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,\n      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${vv}_s`,\n    )\n  } else if (len === 0) {\n    stmts.push(`${ind(ctx)}const ${vv} = ''`)\n  } else if (len === 1) {\n    const code = value.codePointAt(0)!\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else if (len <= 4) {\n    const checks = Array.from({ length: len }, (_, i) =>\n      `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) !== ${value.codePointAt(i)!}`\n    ).join(' || ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || ${checks}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else {\n    // startsWith(str, pos) avoids allocating a slice \u2014 it handles the bounds check\n    // internally and compares in-place. No first-char guard needed either.\n    stmts.push(\n      ...emitIfFail(ctx, `!input.startsWith(${JSON.stringify(value)}, ${pos})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  }\n\n  const endVar = len === 0 ? pos : `${pos} + ${len}`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction escapeKeywordRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\nfunction emitKeywords(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER {\n  const alt = def.words.map(escapeKeywordRe).join('|')\n  const boundary = def.boundary ? `(?![${def.boundary}])` : ''\n  const flags = def.caseInsensitive ? 'iuy' : 'uy'\n  const source = `(?:${alt})${boundary}`\n  const key = `${source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, '\"keyword\"', pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitRegex(def: Extract<ParserDef, { tag: 'regex' }>, ctx: Ctx, pos: string): ER {\n  const flags = 'y' + def.flags.replace(/[gy]/g, '')\n  const key = `${def.optimizedSource}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(`/${def.source}/`)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, expectedStr, pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitSeqValues(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER & { valueVars: string[] } {\n  const startV = v(ctx, '_start')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${startV} = ${pos}`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  const valueVars: string[] = []\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i > 0 && ctx.activeTrivia) {\n      if (ctx.capturing) {\n        const capFn = ensureTriviaCaptureFn(ctx)\n        const markV = v(ctx, '_mk')\n        const markTl = v(ctx, '_mktl')\n        const markLog = v(ctx, '_mklg')\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(\n          `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n          `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n        )\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      } else {\n        const trivFn = ensureTriviaFn(ctx)\n        stmts.push(`${ind(ctx)}${curV} = ${trivFn}(input, ${curV}, _ctx)`)\n      }\n    }\n    const r = emit(def.parsers[i]!, ctx, curV)\n    stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`)\n    valueVars.push(r.valueVar)\n  }\n\n  return { stmts, valueVar: valueVars[valueVars.length - 1] ?? 'null', endVar: curV, valueVars }\n}\n\nfunction emitSeq(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos)\n  const arrV = v(ctx, '_arr')\n  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(', ')}]`)\n  return { stmts, valueVar: arrV, endVar }\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = JSON.stringify(\n    def.parsers.map(p => {\n      const d = p._def\n      if (d.tag === 'literal') return JSON.stringify(d.value)\n      if (d.tag === 'regex') return `/${d.source}/`\n      return p._tag\n    })\n  )\n\n  // \u2500\u2500 Disjoint: O(1) first-char dispatch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  if (def.disjoint) {\n    const codeV = v(ctx, '_code')\n    const valV = v(ctx, '_chv')\n    const endV = v(ctx, '_che')\n    const stmts: string[] = [\n      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`,\n    ]\n\n    let first = true\n    for (const p of def.parsers) {\n      const cond = firstSetCond(codeV, p._meta.firstSet)\n      const kw = first ? 'if' : 'else if'\n      first = false\n      stmts.push(`${ind(ctx)}${kw} (${cond}) {`)\n      ctx.indent++\n      const r = emit(p, ctx, pos)\n      stmts.push(...r.stmts)\n      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}`)\n      stmts.push(`${ind(ctx)}${endV} = ${r.endVar}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n    }\n    stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n    return { stmts, valueVar: valV, endVar: endV }\n  }\n\n  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 greedyClassify: run the super-regex once, classify by string equality \u2500\u2500\u2500\u2500\n// Single regex exec + O(n_literals) string comparisons. Zero backtracking.\nfunction emitGreedyClassify(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  superIndex: number,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const superParser = def.parsers[superIndex]!\n  const regexDef = getCoreRegexDef(superParser)!\n\n  // Hoist the regex (same mechanism as emitRegex, with dedup)\n  const cleanFlags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n  const reKey = `${regexDef.source}/${cleanFlags}`\n  let reVar = ctx.regexMap.get(reKey)\n  if (reVar === undefined) {\n    reVar = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`)\n    ctx.regexMap.set(reKey, reVar)\n  }\n\n  const matchV = v(ctx, '_gm')\n  const wordV  = v(ctx, '_gw')\n  const endV   = v(ctx, '_ge')\n  const valV   = v(ctx, '_gcv')\n\n  const stmts: string[] = [\n    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,\n    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, allExpected, pos)),\n    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,\n    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,\n    `${ind(ctx)}let ${valV}`,\n  ]\n\n  // For each literal arm: if word === literal, capture + transform chain\n  let first = true\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i === superIndex) continue\n    const p = def.parsers[i]!\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) continue\n\n    const kw = first ? 'if' : 'else if'\n    first = false\n    stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx)\n    stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV))\n    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n\n  // Regex arm: capture + transform chain for the matched word\n  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx)\n  const regexKw = first ? 'if' : 'else'\n  stmts.push(`${ind(ctx)}${regexKw} {`)\n  ctx.indent++\n  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 literalsLongestFirst: sorted startsWith checks, no backtracking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfunction emitLiteralsLongestFirst(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  sortedIndices: number[],\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const valV = v(ctx, '_llv')\n  const endV = v(ctx, '_lle')\n  const stmts: string[] = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`]\n\n  let first = true\n  for (const idx of sortedIndices) {\n    const p = def.parsers[idx]!\n    const litVal = getCoreLiteralValue(p)!\n    const litLen = litVal.length\n\n    // Emit the literal check as a direct condition (no IIFE/try-catch \u2014 literals never throw)\n    const litCond = emitLiteralCondition(litVal, pos)\n    const kw = first ? 'if' : 'else if'\n    first = false\n\n    const litEnd = `${pos} + ${litLen}`\n    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx)\n    stmts.push(\n      ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),\n      ...tR.stmts,\n      `${ind(ctx)}${valV} = ${tR.valueVar}`,\n      `${ind(ctx)}${endV} = ${litEnd}`,\n    )\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n  stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 firstMatch fallback: PEG + auto-not inline rejection + per-arm gates \u2500\u2500\u2500\u2500\u2500\n// Uses labeled blocks (emitFallible) instead of IIFE+try/catch to avoid V8\n// deoptimization from exception-based control flow.\nfunction emitFirstMatch(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const resValV = v(ctx, '_crv')\n  const resEndV = v(ctx, '_cre')\n  const resOkV  = v(ctx, '_crok')\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n  ]\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const p = def.parsers[i]!\n    const gate    = def.gates[i]\n    const autoNot = def.autoNot[i]\n\n    // Gate: register predicate in mapFns; condition guards entire arm attempt\n    let gateCond: string | null = null\n    if (gate) {\n      const gateIdx = ctx.mapFns.length\n      ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n      gateCond = `_mf[${gateIdx}](_ctx.state)`\n    }\n    const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`\n\n    // In capturing mode, save leaf-array lengths before the arm so we can roll\n    // back any leaves pushed by a failed or auto-not-rejected arm.\n    const markLeaves = ctx.capturing ? v(ctx, '_cml') : null\n    const markRaw    = ctx.capturing ? v(ctx, '_cmr') : null\n    const markTl     = ctx.capturing ? v(ctx, '_cmtl') : null\n    const markLog    = ctx.capturing ? v(ctx, '_cmlg') : null\n    const rollback   = markLeaves\n      ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLeaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRaw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}`\n      : ''\n\n    stmts.push(`${ind0}if (${skipCond}) {`)\n\n    ctx.indent++\n    const ind1 = ind(ctx)\n    if (markLeaves) {\n      stmts.push(\n        `${ind1}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,\n        `${ind1}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,\n        `${ind1}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,\n        `${ind1}const ${markLog} = _ctx._triviaLog?.length ?? 0`,\n      )\n    }\n    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n    stmts.push(...armStmts)\n    ctx.indent--\n\n    if (autoNot && autoNot.length > 0) {\n      const anCode = v(ctx, '_anc')\n      const rejectCond = autoNot.map(check =>\n        check.kind === 'firstSet'\n          ? firstSetCond(anCode, check.set)\n          : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`\n      ).join(' || ')\n      stmts.push(`${ind0}  if (${okVar}) {`)\n      stmts.push(`${ind0}    const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`)\n      stmts.push(`${ind0}    if (!(${rejectCond})) {`)\n      stmts.push(`${ind0}      ${resValV} = ${valVar}`)\n      stmts.push(`${ind0}      ${resEndV} = ${endVar}`)\n      stmts.push(`${ind0}      ${resOkV} = true`)\n      stmts.push(`${ind0}    }`)\n      stmts.push(`${ind0}  }`)\n      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind0}  if (${okVar}) {`)\n      stmts.push(`${ind0}    ${resValV} = ${valVar}`)\n      stmts.push(`${ind0}    ${resEndV} = ${endVar}`)\n      stmts.push(`${ind0}    ${resOkV} = true`)\n      stmts.push(`${ind0}  }`)\n      if (rollback) stmts.push(`${ind0}  else { ${rollback} }`)\n    }\n    stmts.push(`${ind0}}`)\n  }\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, allExpected, pos)))\n  return { stmts, valueVar: resValV, endVar: resEndV }\n}\n\nfunction emitNonDisjoint(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  strategy: ChoiceStrategy,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  if (strategy.tag === 'greedyClassify')\n    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 helpers for emitGreedyClassify / emitLiteralsLongestFirst \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Apply transform chain only \u2014 no parsing, value already known. */\nfunction emitTransformChain(p: Combinator<unknown>, baseValue: string, endV: string, startPos: string, ctx: Ctx): ER {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx)\n    const fnIdx = ctx.mapFns.length\n    ctx.mapFns.push(def.fn)\n    ctx.mapFnSrcs.push(def.fnSrc ?? null)\n    const vv = v(ctx)\n    return {\n      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],\n      valueVar: vv,\n      endVar: endV,\n    }\n  }\n  return { stmts: [], valueVar: baseValue, endVar: endV }\n}\n\n/** Emit a condition that is true iff input matches `litVal` at `pos`. No side effects. */\nfunction emitLiteralCondition(litVal: string, pos: string): string {\n  const len = litVal.length\n  if (len === 0) return 'true'\n  if (len > 4) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`\n  // Short string: charCodeAt checks (same as emitLit)\n  const checks = [`${pos} + ${len} <= input.length`]\n  for (let i = 0; i < len; i++) {\n    const code = litVal.codePointAt(i)!\n    checks.push(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) === ${code}`)\n  }\n  return checks.join(' && ')\n}\n\nfunction emitMany(def: Extract<ParserDef, { tag: 'many' | 'oneOrMore' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n\n  if (def.min === 1) {\n    // Inline first mandatory match with early-return on failure\n    const firstR = emit(def.parser, ctx, curV)\n    stmts.push(...firstR.stmts)\n    stmts.push(\n      `${ind(ctx)}${arrV}.push(${firstR.valueVar})`,\n      `${ind(ctx)}${curV} = ${firstR.endVar}`,\n    )\n  }\n\n  stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n  ctx.indent++\n\n  // Mirror interpreter repeat.ts \u2014 skip trivia before each iteration. In capture\n  // mode the trivia is committed to rawChildren immediately and rolled back\n  // (array truncation) if the following item doesn't materialize.\n  let itemPos = curV\n  let rollback = ''\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const npV = v(ctx, '_np')\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      itemPos = npV\n      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`)\n      itemPos = npV\n    }\n  }\n\n  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos)\n  stmts.push(\n    ...iterStmts,\n    `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`,\n    `${ind(ctx)}${arrV}.push(${iterVal})`,\n    `${ind(ctx)}${curV} = ${iterEnd}`,\n  )\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitOptional(def: Extract<ParserDef, { tag: 'optional' }>, ctx: Ctx, pos: string): ER {\n  const valV = v(ctx, '_opt')\n  const endV = v(ctx, '_opte')\n\n  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0 = ind(ctx)\n  const stmts = [\n    ...lblStmts,\n    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,\n    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`,\n  ]\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitSepBy(_p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'sepBy' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n\n  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } =\n    emitFallible(def.parser, ctx, pos)\n\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    ...firstStmts,\n    `${ind(ctx)}if (${firstOk}) {`,\n  ]\n  ctx.indent++\n  stmts.push(\n    `${ind(ctx)}${arrV}.push(${firstVal})`,\n    `${ind(ctx)}${curV} = ${firstEnd}`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  )\n  ctx.indent++\n\n  // Mirror interpreter sepBy \u2014 separate rollback marks for pre-sep and post-sep trivia.\n  let sepAtPos = curV\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const markLv = v(ctx, '_mklv')\n      const spV = v(ctx, '_sp')\n      // Marks taken BEFORE the separator. If either the separator OR the following\n      // item fails, the whole iteration unwinds to here \u2014 crucially undoing the\n      // separator's own captured leaves (markLv) when the item after it fails.\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      sepAtPos = spV\n      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV)\n      stmts.push(\n        ...nextStmts,\n        // item failed \u2192 unwind the separator too, back to the end of the last item\n        `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`,\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const spV = v(ctx, '_sp')\n      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`)\n      sepAtPos = spV\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV)\n      stmts.push(\n        ...nextStmts,\n        `${ind(ctx)}if (!${nextOk}) break`,\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    }\n  } else {\n    // No trivia. Still mark the leaf buffers before the separator so that an item\n    // failing after the separator unwinds the separator's captured leaves too.\n    const markLv = ctx.capturing ? v(ctx, '_mklv') : null\n    const markRw = ctx.capturing ? v(ctx, '_mkrw') : null\n    if (markLv) {\n      stmts.push(\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n      )\n    }\n    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n    const nextRb = markLv\n      ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; `\n      : ''\n    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n      emitFallible(def.parser, ctx, sepEnd)\n    stmts.push(\n      ...nextStmts,\n      `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`,\n      `${ind(ctx)}${arrV}.push(${nextVal})`,\n      `${ind(ctx)}${curV} = ${nextEnd}`,\n    )\n  }\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitScanTo(\n  def: Extract<ParserDef, { tag: 'scanTo' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const curV   = v(ctx, '_stcur')\n  const foundV = v(ctx, '_stfnd')\n  const stmts: string[] = [\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    `${ind(ctx)}let ${foundV} = false`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  ]\n  ctx.indent++\n\n  // Sentinel check and skippers must not emit CST leaves \u2014 they are pure position\n  // probes. Use a non-capturing ctx so their literal()/regex() don't push leaves.\n  const probeCtx: Ctx = { ...ctx, capturing: false }\n\n  // Sentinel check \u2014 labeled block, no IIFE\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV)\n  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`)\n\n  // Skippers \u2014 labeled block per skipper; a failure just means \"not this one\"\n  if (def.skip.length > 0) {\n    const advV = v(ctx, '_stadv')\n    stmts.push(`${ind(ctx)}let ${advV} = false`)\n    for (const skipper of def.skip) {\n      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV)\n      stmts.push(\n        `${ind(ctx)}if (!${advV}) {`,\n        ...skStmts,\n        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,\n        `${ind(ctx)}}`,\n      )\n    }\n    stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`)\n  } else {\n    stmts.push(`${ind(ctx)}${curV}++`)\n  }\n\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  // Fail if sentinel was never found (unless orEOF)\n  if (!def.orEOF) {\n    const sentDef = def.sentinel._def\n    const expectedStr = sentDef.tag === 'literal'\n      ? JSON.stringify([JSON.stringify(sentDef.value)])\n      : `[\"sentinel\"]`\n    stmts.push(...emitIfFail(ctx, `!${foundV}`, failArrBody(ctx, expectedStr, pos)))\n  }\n\n  const valV = v(ctx)\n  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`)\n  // scanTo records its scanned span as one leaf (matching the interpreter), but\n  // only when it actually consumed something.\n  if (ctx.capturing) {\n    const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1)\n    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`)\n  }\n  return { stmts, valueVar: valV, endVar: curV }\n}\n\n/**\n * Negative lookahead. Run the inner parser in a labeled block; if it succeeds,\n * fail; if it fails, succeed consuming nothing (value null, end === pos).\n */\nfunction emitNot(def: Extract<ParserDef, { tag: 'not' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, okVar } = emitFallible(def.parser, ctx, pos)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, '\"not\"', pos)),\n    ],\n    valueVar: 'null',\n    endVar: pos,\n  }\n}\n\n/**\n * CST node rule. Collects the inner parse's terminals/trivia into fresh local\n * arrays (capture is emitted inline by the terminals while capChildren is set),\n * calls the build fn, then records the node in the enclosing node()'s collectors.\n */\nfunction emitNode(def: Extract<ParserDef, { tag: 'node' }>, ctx: Ctx, pos: string): ER {\n  const mkType = analyzeMkInlineBuild(def)\n  let buildIdx: number | null = null\n  if (!mkType) {\n    buildIdx = ctx.buildFns.length\n    ctx.buildFns.push(def.build)\n    ctx.buildSrcs.push(def.buildSrc ?? null)\n  }\n  const i = ind(ctx)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const tlV = v(ctx, '_tl')\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  const stmts: string[] = [\n    `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`,\n    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,\n    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${tlV}`,\n  ]\n  const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos)\n  stmts.push(...innerStmts)\n  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`)\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, failBody(ctx, '\"node\"', pos)))\n\n  const stV = v(ctx, '_nst')\n  stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  const ndV = v(ctx, '_nd')\n  const ndExpr = mkType\n    ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV)\n    : `_build[${buildIdx!}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`\n  stmts.push(\n    `${i}const ${ndV} = ${ndExpr}`,\n    `${i}if (${sc}) ${sc}.push(${ndV})`,\n    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`,\n  )\n\n  return { stmts, valueVar: ndV, endVar }\n}\n\nfunction emitRuntimeFallback(parser: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const idx = ctx.runtimeParsers.length\n  ctx.runtimeParsers.push(parser)\n  const rv = v(ctx, '_rt')\n  const vv = v(ctx, '_rtv')\n  const ev = v(ctx, '_rte')\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failBody(ctx, '\"runtime\"', pos)),\n    `${ind(ctx)}const ${vv} = ${rv}.value`,\n    `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n  ]\n  return { stmts, valueVar: vv, endVar: ev }\n}\n\n/**\n * Compile a lazy/ref parser into a named function declaration.\n *\n * The named function is registered in ctx.namedParsers BEFORE its body is\n * emitted. This breaks the recursion cycle: when the body emitter encounters\n * the same ref again it finds it already registered and emits a call instead\n * of recursing infinitely.\n *\n * All named functions share the parent function's scope (via closure), so they\n * can read _rp, _mf, and all hoisted regex consts without extra args.\n *\n * JavaScript hoists function declarations within a function body, so the order\n * we push to namedFnDecls doesn't affect correctness.\n */\nfunction emitLazy(p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'lazy' }>, ctx: Ctx, pos: string): ER {\n  if (!ctx.namedParsers.has(p)) {\n    const fnName = `_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST so recursive refs see it\n\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      // ref.define() not called yet \u2014 fall back to runtime\n      ctx.namedParsers.delete(p)\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in fn body)\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n  }\n\n  const fnName = ctx.namedParsers.get(p)!\n  return emitNamedFnCall(ctx, fnName, pos, '\"parser\"')\n}\n\n// \u2500\u2500 recover: try inner; on failure scan to sentinel, emit ParseError node \u2500\u2500\u2500\u2500\nfunction emitRecover(def: Extract<ParserDef, { tag: 'recover' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0  = ind(ctx)\n  const scanV = v(ctx, '_sc')\n  const errV  = v(ctx, '_err')\n\n  // Sentinel check runs inside the while loop.\n  const whileBodyLevels = ctx.indent + 2\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV)\n\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  let ${scanV} = ${pos}`,\n    `${ind0}  while (${scanV} < input.length) {`,\n    ...reindentStmts(sentStmts, whileBodyLevels),\n    `${ind0}    if (${sentOk}) break`,\n    `${ind0}    ${scanV}++`,\n    `${ind0}  }`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: [] }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${scanV}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// ---------------------------------------------------------------------------\n// Main dispatch\n// ---------------------------------------------------------------------------\nfunction emit(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':   return emitLit(def, ctx, pos)\n    case 'regex':     return emitRegex(def, ctx, pos)\n    case 'keywords':  return emitKeywords(def, ctx, pos)\n    case 'sequence':  return emitSeq(def, ctx, pos)\n    case 'choice':    return emitChoice(def, ctx, pos)\n    case 'many':\n    case 'oneOrMore': return emitMany(def, ctx, pos)\n    case 'optional':  return emitOptional(def, ctx, pos)\n    case 'sepBy':     return emitSepBy(p, def, ctx, pos)\n    case 'transform': {\n      const fnSrc = transformFnSource(def.fn, def.fnSrc)\n      if (fnSrc && def.parser._def.tag === 'sequence') {\n        const seqR = emitSeqValues(def.parser._def, ctx, pos)\n        const inlined = tryInlineDestructureTransform(fnSrc, seqR.valueVars)\n        if (inlined) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...seqR.stmts, `${ind(ctx)}const ${mv} = ${inlined}`],\n            valueVar: mv,\n            endVar: seqR.endVar,\n          }\n        }\n      }\n      const inner = emit(def.parser, ctx, pos)\n      if (fnSrc) {\n        const unary = tryInlineUnaryTransform(fnSrc, inner.valueVar)\n        if (unary) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...inner.stmts, `${ind(ctx)}const ${mv} = ${unary}`],\n            valueVar: mv,\n            endVar: inner.endVar,\n          }\n        }\n      }\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.fn)\n      ctx.mapFnSrcs.push(def.fnSrc ?? null)\n      const mv = v(ctx, '_mapped')\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}const ${mv} = _mf[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`,\n        ],\n        valueVar: mv,\n        endVar: inner.endVar,\n      }\n    }\n    case 'skip': {\n      const mainR = emit(def.main, ctx, pos)\n      const skipR = emit(def.skipped, ctx, mainR.endVar)\n      // skipped is optional \u2014 if it fails we just keep main's end\n      const endV = v(ctx, '_skipe')\n      return {\n        stmts: [\n          ...mainR.stmts,\n          // try skipped; if fails, keep main end\n          `${ind(ctx)}let ${endV} = ${mainR.endVar}`,\n          `${ind(ctx)}try {`,\n          ...reindentStmts(skipR.stmts, ctx.indent + 1),\n          `${ind(ctx)}  ${endV} = ${skipR.endVar}`,\n          `${ind(ctx)}} catch {}`,\n        ],\n        valueVar: mainR.valueVar,\n        endVar: endV,\n      }\n    }\n    case 'lazy':     return emitLazy(p, def, ctx, pos)\n    case 'trivia':   return emit(def.parser, ctx, pos)\n    case 'label':    return emit(def.parser, ctx, pos)\n    case 'grammar': {\n      const savedTrivia = ctx.activeTrivia\n      const savedKindLabels = ctx.triviaKindLabels\n      if (def.clearTrivia) {\n        // noTrivia / parser({ trivia: null }): contiguous terms, no trivia skipped.\n        ctx.activeTrivia = undefined\n        ctx.triviaKindLabels = undefined\n      } else if (def.triviaParser) {\n        ctx.activeTrivia = def.triviaParser\n        if (def.triviaParser._meta.triviaKindLabels) {\n          ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels\n        }\n      }\n      const r = emit(def.parser, ctx, pos)\n      ctx.activeTrivia = savedTrivia\n      ctx.triviaKindLabels = savedKindLabels\n      return r\n    }\n    case 'not':     return emitNot(def, ctx, pos)\n    case 'node':    return emitNode(def, ctx, pos)\n    case 'scanTo':  return emitScanTo(def, ctx, pos)\n    case 'recover': return emitRecover(def, ctx, pos)\n    case 'guard': {\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.predicate as (v: unknown, span: unknown) => unknown)\n      const vv = v(ctx)\n      return {\n        stmts: [\n          ...emitIfFail(ctx, `!_mf[${fnIdx}](_ctx.state)`, failBody(ctx, '\"gate\"', pos)),\n          `${ind(ctx)}const ${vv} = null`,\n        ],\n        valueVar: vv,\n        endVar: pos,\n      }\n    }\n    case 'withCtx': {\n      // Store getter for extra value \u2014 _mf[N]() returns the captured value.\n      const evIdx = ctx.mapFns.length\n      const extra = def.extra\n      ctx.mapFns.push((() => extra) as (v: unknown, span: unknown) => unknown)\n\n      // Wrap inner parser as a named function so it receives _ctx as a parameter.\n      // That lets us call it with a modified ctx (user changed) without polluting\n      // the outer _ctx variable for subsequent emits.\n      const innerParser = def.parser as Combinator<unknown>\n      if (!ctx.namedParsers.has(innerParser)) {\n        const fnName = `_wcf${ctx.namedParsers.size}`\n        ctx.namedParsers.set(innerParser, fnName)\n        const savedIndent    = ctx.indent\n        const savedFailLabel = ctx.failLabel\n        ctx.indent    = 1\n        ctx.failLabel = '_pfail'  // failures break _pfail (same as emitLazy)\n        const innerR = emit(innerParser, ctx, '_pos')\n        ctx.indent    = savedIndent\n        ctx.failLabel = savedFailLabel\n        pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar)\n      }\n      const fn = ctx.namedParsers.get(innerParser)!\n\n      const rv = v(ctx, '_wcr')\n      const vv = v(ctx, '_wcv')\n      const ev = v(ctx, '_wce')\n      return {\n        stmts: [\n          `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,\n          `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, '\"withCtx\"', pos)),\n          `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n        ],\n        valueVar: vv,\n        endVar: ev,\n      }\n    }\n    default:         return emitRuntimeFallback(p, ctx, pos)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\nexport type CompiledParser<T> = {\n  parse(input: string, pos?: number): ParseResult<T>\n  /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */\n  parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>\n  /**\n   * Like parse(), but activates error recovery. recover() nodes collect their\n   * ParseErrors into result.errors instead of (only) embedding them as values.\n   * Always returns ParseOk \u2014 top-level failures are still ParseFail.\n   */\n  parseWithErrors(input: string, pos?: number): ParseResult<T> & { errors: ParseError[] }\n  /** The generated source (for inspection / future source maps) */\n  source: string\n  /**\n   * A self-contained JS expression (IIFE) that evaluates to a parse function.\n   * Safe to inline directly into transformed source \u2014 no external references\n   * except for runtime-fallback parsers embedded via closures.\n   * Returns null if the parser cannot be fully inlined (e.g. contains user\n   * closures that can't be serialized).\n   */\n  inlineExpression: string | null\n}\n\n/**\n * Does this combinator tree contain a node() anywhere (following ref/lazy\n * thunks)? Determines whether the compile emits CST capture \u2014 so non-node\n * grammars stay byte-identical. `seen` guards against recursion cycles.\n */\nfunction hasNodeDef(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'node':      return true\n    case 'lazy':      { try { return hasNodeDef(d.thunk(), seen) } catch { return false } }\n    case 'grammar':\n    case 'trivia':\n    case 'label':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'not':\n    case 'transform': return hasNodeDef(d.parser, seen)\n    case 'skip':      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen)\n    case 'sequence':\n    case 'choice':    return d.parsers.some(x => hasNodeDef(x, seen))\n    case 'sepBy':     return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen)\n    case 'scanTo':    return hasNodeDef(d.sentinel, seen) || d.skip.some(x => hasNodeDef(x, seen))\n    case 'recover':   return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen)\n    case 'withCtx':   return hasNodeDef(d.parser, seen)\n    default:          return false\n  }\n}\n\n/**\n * Compile a combinator tree into an optimized parse function at runtime.\n *\n * Uses `new Function` internally, so it will fail in environments with a strict\n * Content Security Policy that omits `'unsafe-eval'`. Prefer the interpreter or\n * macro build plugin in those cases.\n *\n * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide\n */\nexport function compile<T>(combinator: Combinator<T>, mapFnSources?: string[]): CompiledParser<T> {\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    needsCollator: false,\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: hasNodeDef(combinator as Combinator<unknown>),\n  }\n\n  const r = emit(combinator as Combinator<unknown>, ctx, '_pos')\n\n  const collatorDecl = ctx.needsCollator\n    ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })\\n`\n    : ''\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ''] : []\n\n  const source = [\n    ...ctx.regexDecls,\n    '',\n    ...namedPrelude,\n    ctx.namedFnDecls.join('\\n\\n'),\n    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  const fn = new Function('input', '_pos', '_rp', '_mf', '_build', '_ctx', [\n    ...ctx.regexDecls,\n    collatorDecl,\n    ...namedPrelude,\n    ...ctx.namedFnDecls.flatMap((decl, i) => (i > 0 ? ['', decl] : [decl])),\n    `let pos = _pos`,\n    ...r.stmts,\n    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ].join('\\n')) as (\n    input: string,\n    pos: number,\n    rp: Array<Combinator<unknown>>,\n    mf: Array<(v: unknown, span: { start: number; end: number }) => unknown>,\n    build: Ctx['buildFns'],\n    ctx: ParseContext,\n  ) => ParseResult<T>\n\n  const defaultCtx: ParseContext = {\n    trackLines: false,\n    ...(ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}),\n  }\n\n  // Prefer per-def sources captured in codegen-traversal order (set by the\n  // macro via def.fnSrc). Fall back to a caller-provided positional array.\n  // The derived array is only usable when every traversed transform carried a\n  // source \u2014 otherwise we can't inline the closures.\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const effectiveSources = mapFnSources ?? derivedSrcs\n\n  // node() build fns inline the same way: every traversed node must carry its\n  // build source (set by the macro via def.buildSrc) or we can't inline.\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n\n  // Build an inline expression when there are no runtime fallbacks, and either\n  // no map-function closures or their source text has been provided for injection.\n  const mfCovered = ctx.mapFns.length === 0 || (effectiveSources !== undefined && effectiveSources.length === ctx.mapFns.length)\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  const inlineExpression: string | null = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null\n\n  return {\n    source,\n    inlineExpression,\n    parse(input: string, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx)\n    },\n    parseWithContext(input: string, parseCtx: ParseContext, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx)\n    },\n    parseWithErrors(input: string, pos = 0): ParseResult<T> & { errors: ParseError[] } {\n      const errors: ParseError[] = []\n      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors })\n      return { ...result, errors } as ParseResult<T> & { errors: ParseError[] }\n    },\n  }\n}\n\nfunction buildInlineExpression(\n  ctx: Ctx,\n  r: ER,\n  collatorDecl: string,\n  mapFnSources?: string[],\n  buildSources?: string[],\n): string {\n  const bodyLines = [\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ]\n\n  const innerFn = [\n    `function(input, _pos, _ctx) {`,\n    ...bodyLines,\n    `}`,\n  ].join('\\n')\n\n  // Declare _mf / _build inline so the emitted _mf[i] / _build[i] references\n  // resolve without runtime closure arrays.\n  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(', ')}]` : ''\n\n  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    collatorDecl ? `  ${collatorDecl.trim()}` : '',\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n  return [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return ${innerFn}`,\n    `})()`,\n  ].join('\\n')\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Zero-width assertion: succeeds (consuming nothing) only when `predicate`\n * returns true for `ctx.state`. Fails otherwise.\n *\n * Intended for use inside sequence() to gate subsequent parsing on runtime\n * context set with withCtx().\n *\n *   const returnStmt = sequence(\n *     guard(ctx => (ctx as { inFn: boolean }).inFn),\n *     literal('return'), optional(expr)\n *   )\n */\nexport function guard(predicate: (state: unknown) => boolean): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'guard',\n    _meta: meta,\n    _def: { tag: 'guard', predicate },\n    parse(_input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      if (predicate(ctx.state))\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      return { ok: false, expected: ['guard'], span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Runs `combinator` with `ctx.state` set to `extra` for the duration of the parse.\n * The outer user context is restored on exit (lexical scoping).\n *\n *   const functionBody = withCtx({ inFn: true },\n *     sequence(literal('{'), many(statement), literal('}'))\n *   )\n *\n * Read back with guard() or from within a transform's span argument.\n */\nexport function withCtx<U, T>(extra: U, combinator: Combinator<T>): Combinator<T> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'withCtx',\n    _meta: meta,\n    _def: { tag: 'withCtx', extra, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      return combinator.parse(input, pos, { ...ctx, state: extra })\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\n\nexport type { ParseError }\n\n/**\n * Error-recovery combinator. Tries `combinator`; on success returns normally.\n * On failure, scans forward one character at a time until `sentinel` matches\n * (or EOF), then returns a ParseError node spanning the skipped range.\n * The sentinel is NOT consumed \u2014 the caller's grammar continues from there.\n *\n * Intended for IDE/incremental parsers that must produce a result even on\n * broken input. The error path is not optimized; use only where recovery\n * is genuinely needed, not on hot paths.\n *\n *   const stmt = choice(\n *     ifStmt, whileStmt,\n *     recover(exprStmt, literal(';'))\n *   )\n */\nexport function recover<T>(\n  combinator: Combinator<T>,\n  sentinel: Combinator<unknown>,\n): Combinator<T | ParseError> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'recover',\n    _meta: meta,\n    _def: { tag: 'recover', parser: combinator as Combinator<unknown>, sentinel },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n\n      let scanPos = pos\n      while (scanPos < input.length) {\n        if (sentinel.parse(input, scanPos, ctx).ok) break\n        scanPos++\n      }\n\n      const error: ParseError = {\n        _tag: 'parseError',\n        span: { start: pos, end: scanPos },\n        expected: result.expected,\n      }\n      ctx._errors?.push(error)\n      return { ok: true, value: error, span: { start: pos, end: scanPos } }\n    },\n  }\n}\n\nexport function isParseError(value: unknown): value is ParseError {\n  return typeof value === 'object' && value !== null && (value as ParseError)._tag === 'parseError'\n}\n", "import type { Combinator, ParseFail, ParseContext } from '../types.ts'\n\n/**\n * Returns the set of expected tokens at the given cursor offset.\n * Useful for implementing IDE completions.\n *\n * Runs the parser on input truncated at `offset` with a probe that tracks the\n * highest-position failure seen, even when sepBy/many backtrack past the cursor.\n * Returns the expected tokens from that deepest failure.\n *\n * Returns an empty array when the input up to `offset` parses completely\n * with no failures at or before the cursor.\n *\n * The returned strings use the same labels as ParseFail.expected:\n * quoted literals like `\"\\\"{\\\"\"` and regex patterns like `\"/[0-9]+/\"`.\n */\nexport function completionsAt(\n  combinator: Combinator<unknown>,\n  input: string,\n  offset: number,\n): string[] {\n  const probe: { offset: number; best: ParseFail | null } = { offset, best: null }\n  const ctx: ParseContext = { trackLines: false, _probe: probe }\n  const result = combinator.parse(input.slice(0, offset), 0, ctx)\n\n  // If the parser consumed everything up to offset successfully, there is nothing\n  // to complete \u2014 the input is already valid at this position.\n  if (result.ok) return []\n\n  // Use whichever failure (probe or top-level) sits at the deeper position.\n  const best = deeperFail(probe.best, result)\n  return best?.expected ?? []\n}\n\nfunction deeperFail(a: ParseFail | null, b: ParseFail | null): ParseFail | null {\n  if (!a) return b\n  if (!b) return a\n  return a.span.start >= b.span.start ? a : b\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { literal } from './literal.ts'\nimport { sequence } from './sequence.ts'\nimport { transform } from './map.ts'\nimport { any } from './first-set.ts'\nimport { ref } from './ref.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type ScanToOptions = {\n  /** Parsers that match \"container\" regions to skip over intact (balanced parens, strings, comments\u2026) */\n  skip?: Combinator<unknown>[]\n  /**\n   * If true, reaching EOF without finding the sentinel is a success \u2014 returns\n   * everything consumed so far. Default false (fail at EOF).\n   */\n  orEOF?: boolean\n}\n\n/**\n * Consume input up to (but not including) the sentinel, skipping over any\n * \"hole\" patterns in order so their contents are never mistaken for the sentinel.\n *\n * Returns the consumed text as a string. The sentinel is NOT consumed.\n * Fails if the sentinel is never found (unless orEOF is true).\n *\n *   const selector = scanTo(literal('{'), {\n *     skip: [cssComment, stringLit, balanced('(', ')'), balanced('[', ']')],\n *   })\n */\nexport function scanTo(\n  sentinel: Combinator<unknown>,\n  { skip = [], orEOF = false }: ScanToOptions = {},\n): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'scanTo',\n    _meta: meta,\n    _def: { tag: 'scanTo', sentinel, skip, orEOF },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      let cur = pos\n\n      // Sentinel checks and skip scans must not emit CST children of their own \u2014\n      // scanTo represents the whole scanned span as one leaf. Probe them with a\n      // collector-free context so their internal literal()/regex() don't push.\n      const probeCtx: ParseContext = { trackLines: ctx.trackLines, state: ctx.state }\n\n      // Record the scanned text as a CSTLeaf so buildNode-driven grammars can\n      // see it in children/rawChildren (it would otherwise be lost \u2014 only the\n      // returned value carries it). Skipped when no collector is active.\n      const emit = (end: number) => {\n        if (end > pos && cstCaptureActive(ctx)) {\n          const leaf = { _tag: 'leaf', value: input.slice(pos, end), span: { start: pos, end } }\n          pushCstLeaf(ctx, leaf)\n        }\n      }\n\n      while (cur < input.length) {\n        // Check sentinel \u2014 if it matches here, stop and return consumed text.\n        const s = sentinel.parse(input, cur, probeCtx)\n        if (s.ok) {\n          emit(cur)\n          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n        }\n\n        // Try each skipper in order; take first that advances.\n        let advanced = false\n        for (const skipper of skip) {\n          const r = skipper.parse(input, cur, probeCtx)\n          if (r.ok && r.span.end > cur) {\n            cur = r.span.end\n            advanced = true\n            break\n          }\n        }\n\n        // Nothing matched \u2014 consume one character and continue.\n        if (!advanced) cur++\n      }\n\n      // Reached EOF without finding sentinel.\n      if (orEOF) {\n        emit(cur)\n        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n      }\n      const sentDef = sentinel._def\n      const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']\n      return { ok: false, expected, span: { start: pos, end: cur } }\n    },\n  }\n}\n\n/**\n * Match a balanced open/close pair, skipping over any holes inside.\n * Returns the full matched text including delimiters.\n *\n *   const parenGroup = balanced('(', ')', { skip: [comment, stringLit] })\n */\nexport function balanced(\n  open: string,\n  close: string,\n  options: ScanToOptions = {},\n): Combinator<string> {\n  // The interior scan must skip NESTED same-delimiter pairs so depth is counted \u2014\n  // otherwise `{{x}}` stops at the first `}`. `self` references this balanced\n  // combinator; added to the interior scan's skip list, a nested `open` is\n  // consumed intact (recursively) before the scan looks for the matching `close`.\n  const self = ref<string>()\n  const inner = scanTo(literal(close), {\n    ...options,\n    skip: [self, ...(options.skip ?? [])],\n  })\n  const combi = transform(\n    sequence(literal(open), inner, literal(close)),\n    ([o, content, c]) => o + content + c,\n  )\n  // Provide the callback source so the macro can inline this library-internal\n  // transform (codegen derives map-fn sources from def.fnSrc).\n  if (combi._def.tag === 'transform') {\n    combi._def.fnSrc = '([o, content, c]) => o + content + c'\n  }\n  self.define(combi as Combinator<string>)\n  return combi\n}\n", "/**\n * Functional incremental document \u2014 incremental re-parse over a rules() registry.\n */\nimport type { ParseContext, ParseFail, ParseResult } from '../types.ts'\nimport type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts'\n\n/** A single compiled (or interpreted) rule: parse from `pos`, producing node `N`. */\nexport type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>\n\n/** Rule name \u2192 parser function. This is exactly the shape `rules()` returns. */\nexport type Registry<N> = Record<string, RuleFn<N>>\n\nexport type FunctionalDocOptions<N extends NodeLike> = {\n  /** Initial grammar state threaded into ctx.state for the root parse. */\n  state?: unknown\n  /**\n   * Reconstruct a parent node with one child replaced (used when grafting a\n   * re-parsed subtree into its ancestors). Defaults to a shallow spread, which\n   * works for plain-object nodes; class-instance ASTs should supply their own.\n   */\n  rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N\n}\n\nexport interface FunctionalDoc<N extends NodeLike> {\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n  /**\n   * Incrementally re-parse after a text change. `from`/`to` are byte offsets in\n   * the OLD input; `replacement` fills that range (editor change-event shape).\n   */\n  edit(from: number, to: number, replacement: string): FunctionalDoc<N>\n}\n\n// ---------------------------------------------------------------------------\n// Tree navigation (generic over NodeLike \u2014 no class, no CST assumptions)\n// ---------------------------------------------------------------------------\n\ntype FoundNode<N extends NodeLike> = { node: N; path: number[] }\n\nfunction isNode(x: unknown): x is NodeLike {\n  return typeof x === 'object' && x !== null && (x as { _tag?: string })._tag === 'node'\n}\n\nfunction findContaining<N extends NodeLike>(node: N, pos: number, path: number[] = []): FoundNode<N> | null {\n  for (let i = 0; i < node.children.length; i++) {\n    const child = node.children[i]!\n    if (!isNode(child)) continue\n    if (child.span.start <= pos && pos < child.span.end) {\n      const inner = findContaining(child as N, pos, [...path, i])\n      return inner ?? { node: child as N, path: [...path, i] }\n    }\n  }\n  return null\n}\n\nfunction ancestorsAt<N extends NodeLike>(root: N, path: number[]): N[] {\n  const ancestors: N[] = [root]\n  let cur: N = root\n  for (const idx of path.slice(0, -1)) {\n    const child = cur.children[idx]\n    if (!child || !isNode(child)) break\n    ancestors.push(child as N)\n    cur = child as N\n  }\n  return ancestors\n}\n\nfunction replaceAtPath<N extends NodeLike>(\n  rebuild: NonNullable<FunctionalDocOptions<N>['rebuild']>,\n  root: N,\n  path: number[],\n  newNode: N,\n): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const newChildren = [...root.children] as Array<N | CSTLeaf | CSTError>\n  newChildren[idx] = rest.length === 0\n    ? newNode\n    : replaceAtPath(rebuild, root.children[idx] as N, rest, newNode)\n  return rebuild(root, newChildren)\n}\n\nfunction defaultRebuild<N extends NodeLike>(node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>): N {\n  return { ...node, children } as N\n}\n\n// ---------------------------------------------------------------------------\n// Document\n// ---------------------------------------------------------------------------\n\nclass FunctionalDocImpl<N extends NodeLike> implements FunctionalDoc<N> {\n  private readonly _registry: Registry<N>\n  private readonly _rootRule: string\n  private readonly _opts: FunctionalDocOptions<N>\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n\n  constructor(\n    registry: Registry<N>,\n    rootRule: string,\n    opts: FunctionalDocOptions<N>,\n    tree: N | null,\n    errors: ParseFail[],\n    input: string,\n  ) {\n    this._registry = registry\n    this._rootRule = rootRule\n    this._opts = opts\n    this.tree = tree\n    this.errors = errors\n    this.input = input\n  }\n\n  edit(from: number, to: number, replacement: string): FunctionalDoc<N> {\n    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to)\n    const reparse = () => makeFunctionalDoc(this._registry, this._rootRule, newInput, this._opts)\n\n    if (!this.tree) return reparse()\n\n    const delta = replacement.length - (to - from)\n    const found = findContaining(this.tree, from)\n    if (!found) return reparse()\n\n    // Try the innermost containing rule first, then widen outward.\n    const ancestors = ancestorsAt(this.tree, found.path)\n    const candidates: FoundNode<N>[] = [found]\n    const pathCopy = [...found.path]\n    for (let i = ancestors.length - 2; i >= 0; i--) {\n      pathCopy.pop()\n      candidates.push({ node: ancestors[i + 1]!, path: [...pathCopy] })\n    }\n\n    const rebuild = this._opts.rebuild ?? defaultRebuild\n    for (const { node, path } of candidates) {\n      const ruleFn = this._registry[node.type]\n      if (!ruleFn) continue\n      const ctx: ParseContext = { trackLines: false, state: node.state }\n      const r = ruleFn(newInput, node.span.start, ctx)\n      if (!r.ok) continue\n      if (r.span.end === node.span.end + delta) {\n        const newTree = replaceAtPath(rebuild, this.tree, path, r.value)\n        return new FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput)\n      }\n    }\n\n    return reparse()\n  }\n}\n\n/**\n * Parse `input` from `rootRule` and wrap the result in a FunctionalDoc that can\n * be incrementally re-parsed via `.edit()`.\n */\nexport function makeFunctionalDoc<N extends NodeLike>(\n  registry: Registry<N>,\n  rootRule: string,\n  input: string,\n  opts: FunctionalDocOptions<N> = {},\n): FunctionalDoc<N> {\n  const ruleFn = registry[rootRule]\n  if (!ruleFn) throw new Error(`No rule '${rootRule}' in registry`)\n  const ctx: ParseContext = { trackLines: false, state: opts.state }\n  const r: ParseResult<N> = ruleFn(input, 0, ctx)\n  if (r.ok) {\n    return new FunctionalDocImpl(registry, rootRule, opts, r.value, [], input)\n  }\n  return new FunctionalDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input)\n}\n", "import type { Span } from '../types.ts'\n\n/** One captured trivia token (a whitespace run or a comment) with its source span. */\nexport type TriviaToken = { readonly value: string; readonly span: Span }\n\n/**\n * Before/after offset index of captured trivia. Built from a tree whose nodes\n * carry a `triviaLog` property (the flat `[start, end, insertIdx, ...]` array\n * produced by parseman when `parser({ captureTrivia: true })` wraps a `node()` grammar).\n *\n *   index.before.get(node.span.start)  // trivia immediately before a node\n *   index.after.get(node.span.end)     // trivia immediately after a node\n *\n * A given trivia entry is registered under BOTH the following item's start\n * (`before`) and the preceding item's end (`after`), so either lookup finds it.\n */\nexport type TriviaIndex = {\n  readonly before: Map<number, TriviaToken[]>\n  readonly after: Map<number, TriviaToken[]>\n}\n\ntype Spanned = { readonly span: Span }\ntype NodeWithTrivia = {\n  readonly span?: Span\n  readonly children?: ReadonlyArray<unknown>\n  readonly rawChildren?: ReadonlyArray<Spanned>\n  readonly triviaLog?: readonly number[]\n}\n\nfunction merge(map: Map<number, TriviaToken[]>, key: number, run: TriviaToken[]): void {\n  if (run.length === 0) return\n  const existing = map.get(key)\n  if (existing) existing.push(...run)\n  else map.set(key, [...run])\n}\n\n/**\n * Options for trailing/leading trivia at the document boundary. A repeating root\n * (e.g. `many()`) rolls back the trivia after its last item \u2014 it's \"trailing\" and\n * belongs to the enclosing context, which at the document root is the document\n * itself. Pass `{ trivia }` to re-scan and register that boundary trivia,\n * so a round-trippable trivia map isn't missing the run before EOF.\n */\nexport type TriviaIndexOptions = {\n  /**\n   * A regex matching ONE trivia token (a whitespace run or a comment). Applied\n   * repeatedly to tokenize the boundary trivia. Each match becomes one token, so\n   * write it to match a maximal run, e.g.\n   * `/[ \\t\\n\\r\\f]+|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//`.\n   */\n  trivia: RegExp\n}\n\n/**\n * Walk a tree whose nodes carry `triviaLog` (from `node()` + `captureTrivia`)\n * and build a before/after trivia index. Each node must have\n * `triviaLog: readonly number[]` (flat `[start, end, insertIdx, \u2026]` \u2014\n * three numbers per entry) and `rawChildren` (structural items with `.span`).\n * `input` is the source string used to materialize trivia values.\n *\n * With `opts`, also captures leading trivia (before the root's content) and\n * trailing trivia (after it, up to EOF) \u2014 the document boundaries a repeating\n * root rolls back.\n */\nexport function buildTriviaIndex(root: unknown, input = '', opts?: TriviaIndexOptions): TriviaIndex {\n  const before = new Map<number, TriviaToken[]>()\n  const after = new Map<number, TriviaToken[]>()\n\n  const visit = (node: NodeWithTrivia): void => {\n    const log = node.triviaLog\n    const raw = node.rawChildren\n\n    if (log && log.length && raw) {\n      for (let i = 0; i < log.length; i += 3) {\n        const tStart = log[i]!, tEnd = log[i + 1]!, insertIdx = log[i + 2]!\n        if (tEnd <= tStart) continue\n        const run: TriviaToken[] = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }]\n        const next = raw[insertIdx]\n        if (next) merge(before, next.span.start, run)\n        const prev = insertIdx > 0 ? raw[insertIdx - 1] : undefined\n        if (prev) merge(after, prev.span.end, run)\n      }\n    }\n\n    const ch = node.children\n    if (ch) {\n      for (const c of ch) {\n        if (typeof c === 'object' && c !== null && (c as NodeWithTrivia).children !== undefined) {\n          visit(c as NodeWithTrivia)\n        }\n      }\n    }\n  }\n\n  if (root) visit(root as NodeWithTrivia)\n\n  // Document-boundary trivia: re-scan leading (offset 0) and trailing (root end\n  // \u2192 EOF) trivia that a repeating root rolled back.\n  if (opts && input) {\n    const rootSpan = (root as NodeWithTrivia | null)?.span\n    const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, '') + 'y')\n    const scanFrom = (from: number): TriviaToken[] => {\n      const run: TriviaToken[] = []\n      let pos = from\n      re.lastIndex = pos\n      let m = re.exec(input)\n      while (m && m.index === pos && m[0].length > 0) {\n        run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } })\n        pos += m[0].length\n        re.lastIndex = pos\n        m = re.exec(input)\n      }\n      return run\n    }\n\n    if (rootSpan && rootSpan.start > 0) {\n      const lead = scanFrom(0)\n      if (lead.length) merge(before, rootSpan.start, lead)\n    }\n    const end = rootSpan ? rootSpan.end : 0\n    if (end < input.length) {\n      const trail = scanFrom(end)\n      if (trail.length) {\n        merge(after, end, trail)\n        merge(before, end + trail.reduce((n, t) => n + (t.span.end - t.span.start), 0), trail)\n      }\n    }\n  }\n\n  return { before, after }\n}\n", "/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */\nexport type TriviaEntriesView = {\n  readonly length: number\n  readonly labels: readonly string[] | undefined\n  readonly stride: number\n  start(i: number): number\n  end(i: number): number\n  kindIndex(i: number): number | undefined\n  kind(i: number): string | undefined\n  text(i: number, input: string): string\n}\n\nfunction entryOffset(i: number, stride: number): number {\n  return i * stride\n}\n\n/**\n * Wrap a flat trivia log. Stride is inferred from `labels`:\n * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)\n * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)\n */\nexport function triviaEntries(\n  log: readonly number[],\n  labels?: readonly string[],\n  opts?: { nodeLog?: boolean },\n): TriviaEntriesView {\n  const baseStride = opts?.nodeLog ? 3 : 2\n  const stride = labels ? baseStride + 1 : baseStride\n  const length = Math.floor(log.length / stride)\n\n  return {\n    length,\n    labels,\n    stride,\n    start(i) {\n      return log[entryOffset(i, stride)]!\n    },\n    end(i) {\n      return log[entryOffset(i, stride) + 1]!\n    },\n    kindIndex(i) {\n      if (!labels) return undefined\n      return log[entryOffset(i, stride) + baseStride]\n    },\n    kind(i) {\n      const ki = labels ? log[entryOffset(i, stride) + baseStride] : undefined\n      return ki !== undefined ? labels![ki] : undefined\n    },\n    text(i, input) {\n      const s = log[entryOffset(i, stride)]!\n      const e = log[entryOffset(i, stride) + 1]!\n      return input.slice(s, e)\n    },\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["node", "parser", "trivia", "trivia", "tr", "result", "parser", "unwrapTrivia", "trivia", "escapeRegExp", "body", "trivia", "r", "parser", "fnName", "mv", "skip", "emit", "node", "node"]
+  "sources": ["../src/combinators/first-set.ts", "../src/combinators/probe.ts", "../src/cst/capture-buffer.ts", "../src/combinators/literal.ts", "../src/combinators/regex.ts", "../src/combinators/keywords.ts", "../src/combinators/choice.ts", "../src/cst/trivia-kinds.ts", "../src/combinators/trivia-skip.ts", "../src/combinators/sequence.ts", "../src/combinators/repeat.ts", "../src/combinators/ref.ts", "../src/combinators/parser.ts", "../src/combinators/not.ts", "../src/combinators/node.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/compiler/scannable-run.ts", "../src/compiler/trivia-fast-path.ts", "../src/compiler/inline-build.ts", "../src/compiler/inline-callback.ts", "../src/compiler/codegen.ts", "../src/combinators/guard.ts", "../src/combinators/withCtx.ts", "../src/combinators/recover.ts", "../src/combinators/expect.ts", "../src/combinators/completions.ts", "../src/combinators/scanTo.ts", "../src/functional/doc.ts", "../src/cst/trivia-index.ts", "../src/cst/trivia-entries.ts"],
+  "sourcesContent": ["import type { CharRange, FirstSet } from '../types.ts'\n\nexport function union(a: FirstSet, b: FirstSet): FirstSet {\n  if (a.kind === 'any' || b.kind === 'any') return { kind: 'any' }\n  if (a.kind === 'empty') return b\n  if (b.kind === 'empty') return a\n  return { kind: 'ranges', ranges: mergeRanges([...a.ranges, ...b.ranges]) }\n}\n\nexport function intersects(a: FirstSet, b: FirstSet): boolean {\n  if (a.kind === 'any' || b.kind === 'any') return true\n  if (a.kind === 'empty' || b.kind === 'empty') return false\n  for (const ra of a.ranges) {\n    for (const rb of b.ranges) {\n      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true\n    }\n  }\n  return false\n}\n\nexport function fromChar(code: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo: code, hi: code }] }\n}\n\nexport function fromRange(lo: number, hi: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo, hi }] }\n}\n\nexport function any(): FirstSet {\n  return { kind: 'any' }\n}\n\nexport function empty(): FirstSet {\n  return { kind: 'empty' }\n}\n\nfunction mergeRanges(ranges: CharRange[]): CharRange[] {\n  if (ranges.length === 0) return []\n  const sorted = [...ranges].sort((a, b) => a.lo - b.lo)\n  // Always copy \u2014 never alias input objects\n  const out: CharRange[] = [{ lo: sorted[0]!.lo, hi: sorted[0]!.hi }]\n  for (let i = 1; i < sorted.length; i++) {\n    const top = out[out.length - 1]!\n    const cur = sorted[i]!\n    if (cur.lo <= top.hi + 1) {\n      if (cur.hi > top.hi) top.hi = cur.hi\n    } else {\n      out.push({ lo: cur.lo, hi: cur.hi })\n    }\n  }\n  return out\n}\n", "import type { ParseContext, ParseFail } from '../types.ts'\n\n/**\n * Creates a ParseFail and, if a completions probe is active, records it.\n *\n * Rules:\n * - Only failures at or before the probe's target offset are eligible.\n * - A deeper failure (higher pos) replaces the current best.\n * - A tie (same pos) merges expected arrays \u2014 this is what makes choice arms\n *   aggregate their alternatives rather than each overwriting the last.\n * - Shallower failures are ignored.\n */\nexport function failAt(ctx: ParseContext, expected: string[], pos: number): ParseFail {\n  const r: ParseFail = { ok: false, expected, span: { start: pos, end: pos } }\n  const probe = ctx._probe\n  if (probe !== undefined && pos <= probe.offset) {\n    const best = probe.best\n    if (best === null || pos > best.span.start) {\n      probe.best = r\n    } else if (pos === best.span.start) {\n      probe.best = { ...best, expected: [...best.expected, ...expected] }\n    }\n  }\n  return r\n}\n", "import type { ParseContext } from '../types.ts'\n\n/** Lazy per-node capture state \u2014 arrays materialized on first push. */\nexport type CstCaptureBuf = {\n  single?: unknown | undefined\n  ch?: unknown[] | undefined\n  rawSingle?: unknown | undefined\n  raw?: unknown[] | undefined\n  tl?: number[] | undefined\n}\n\nconst EMPTY: unknown[] = []\nconst EMPTY_TL: number[] = []\n\nexport function cstCaptureActive(ctx: ParseContext): boolean {\n  return ctx._cstBuf !== undefined || ctx._cstLeaves !== undefined\n}\n\nexport type CstNodeCaptureSaved = {\n  ch: ParseContext['_cstChildren']\n  lv: ParseContext['_cstLeaves']\n  raw: ParseContext['_cstRawChildren']\n  tl: ParseContext['_cstTriviaLog']\n  cap: boolean | undefined\n  buf: CstCaptureBuf | undefined\n}\n\nexport function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {\n  const saved: CstNodeCaptureSaved = {\n    ch: ctx._cstChildren,\n    lv: ctx._cstLeaves,\n    raw: ctx._cstRawChildren,\n    tl: ctx._cstTriviaLog,\n    cap: ctx.captureTrivia,\n    buf: ctx._cstBuf,\n  }\n  ctx._cstBuf = {}\n  ctx._cstChildren = undefined\n  ctx._cstLeaves = undefined\n  ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined\n  ctx.captureTrivia = true\n  return saved\n}\n\nexport function finishCstBuf(buf: CstCaptureBuf | undefined): {\n  children: unknown[]\n  rawChildren: unknown[]\n  triviaLog: number[]\n} {\n  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL }\n  const children = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY)\n  const rawChildren = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY)\n  const triviaLog = buf.tl ?? EMPTY_TL\n  return { children, rawChildren, triviaLog }\n}\n\nexport function endCstNodeCapture(\n  ctx: ParseContext,\n  saved: CstNodeCaptureSaved,\n): { children: unknown[]; rawChildren: unknown[]; triviaLog: number[] } {\n  const materialized = finishCstBuf(ctx._cstBuf)\n  ctx._cstBuf = saved.buf\n  ctx._cstChildren = saved.ch\n  ctx._cstLeaves = saved.lv\n  ctx._cstRawChildren = saved.raw\n  ctx._cstTriviaLog = saved.tl\n  ctx.captureTrivia = saved.cap\n  return materialized\n}\n\nexport function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {\n  pushCstChild(ctx, leaf, leaf)\n}\n\n/** Record a built sub-node into the active collector (children vs rawChildren may differ). */\nexport function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) b.ch.push(built)\n    else if (b.single !== undefined) { b.ch = [b.single, built]; b.single = undefined }\n    else b.single = built\n\n    if (b.raw) b.raw.push(rawEntry)\n    else if (b.rawSingle !== undefined) { b.raw = [b.rawSingle, rawEntry]; b.rawSingle = undefined }\n    else b.rawSingle = rawEntry\n    return\n  }\n  if (ctx._cstChildren) ctx._cstChildren.push(built)\n  else if (ctx._cstLeaves) ctx._cstLeaves.push(built)\n  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)\n}\n\nexport function cstRawLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.raw) return b.raw.length\n    return b.rawSingle !== undefined ? 1 : 0\n  }\n  return ctx._cstRawChildren?.length ?? 0\n}\n\nexport function cstLeavesLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) return b.ch.length\n    return b.single !== undefined ? 1 : 0\n  }\n  return ctx._cstLeaves?.length ?? 0\n}\n\nexport function cstTlLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) return b.tl?.length ?? 0\n  return ctx._cstTriviaLog?.length ?? 0\n}\n\nexport type CstRollbackMark = { raw: number; tlog: number; leaves: number }\n\nexport function saveCstMark(ctx: ParseContext): CstRollbackMark {\n  return {\n    raw: cstRawLen(ctx),\n    tlog: cstTlLen(ctx),\n    leaves: cstLeavesLen(ctx),\n  }\n}\n\nfunction rollbackBufList(\n  b: CstCaptureBuf,\n  keyMulti: 'ch' | 'raw',\n  keySingle: 'single' | 'rawSingle',\n  len: number,\n): void {\n  const arr = b[keyMulti]\n  if (arr) {\n    if (len === 0) b[keyMulti] = undefined\n    else if (len === 1) { b[keySingle] = arr[0]; b[keyMulti] = undefined }\n    else arr.length = len\n    return\n  }\n  if (len === 0) b[keySingle] = undefined\n}\n\nexport function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void {\n  const b = ctx._cstBuf\n  if (b) {\n    rollbackBufList(b, 'raw', 'rawSingle', mark.raw)\n    rollbackBufList(b, 'ch', 'single', mark.leaves)\n    if (b.tl) {\n      if (mark.tlog === 0) b.tl = undefined\n      else b.tl.length = mark.tlog\n    }\n    return\n  }\n  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw\n  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog\n  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves\n}\n\nexport function pushCstTriviaEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  const insertIdx = cstRawLen(ctx)\n  const b = ctx._cstBuf\n  const withKind = ctx.triviaKindLabels !== undefined && kindIndex !== undefined\n  if (b) {\n    if (!b.tl) {\n      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx]\n    } else if (withKind) {\n      b.tl.push(start, end, insertIdx, kindIndex)\n    } else {\n      b.tl.push(start, end, insertIdx)\n    }\n    return\n  }\n  if (ctx._cstTriviaLog) {\n    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex)\n    else ctx._cstTriviaLog.push(start, end, insertIdx)\n  }\n}\n\nexport function pushTriviaLogEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  if (!ctx._triviaLog) return\n  if (ctx.triviaKindLabels !== undefined && kindIndex !== undefined) {\n    ctx._triviaLog.push(start, end, kindIndex)\n  } else {\n    ctx._triviaLog.push(start, end)\n  }\n}\n\nexport function cstDeferredTriviaActive(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { fromChar, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nlet _collatorCache: Intl.Collator | null = null\nfunction collator(): Intl.Collator {\n  if (_collatorCache === null) {\n    _collatorCache = new Intl.Collator(undefined, { sensitivity: 'accent' })\n  }\n  return _collatorCache\n}\n\nexport type LiteralOptions = {\n  caseInsensitive?: boolean\n}\n\nexport function literal(value: string, opts: LiteralOptions = {}): Combinator<string> {\n  const caseInsensitive = opts.caseInsensitive ?? false\n\n  const firstSet = value.length > 0\n    ? fromChar(value.codePointAt(0)!)\n    : empty()\n\n  const meta: ParserMeta = {\n    firstSet,\n    canMatchNewline: value.includes('\\n'),\n    isTrivia: false,\n  }\n\n  if (caseInsensitive) {\n    const upper = value.toUpperCase()\n    const lower = value.toLowerCase()\n    const firstUpper = upper.codePointAt(0)\n    const firstLower = lower.codePointAt(0)\n    meta.firstSet = firstLower !== undefined && firstUpper !== undefined\n      ? { kind: 'ranges', ranges: [\n          { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }\n        ]}\n      : firstSet\n  }\n\n  return {\n    _tag: 'literal',\n    _meta: meta,\n    _def: { tag: 'literal', value, caseInsensitive },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const end = pos + value.length\n      if (end > input.length) {\n        return failAt(ctx, [JSON.stringify(value)], pos)\n      }\n      const slice = input.slice(pos, end)\n      const matched = caseInsensitive\n        ? collator().compare(slice, value) === 0\n        : slice === value\n      if (matched) {\n        const span = { start: pos, end }\n        const leaf = { _tag: 'leaf', value: slice, span }\n        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n        return { ok: true, value: slice, span }\n      }\n      return failAt(ctx, [JSON.stringify(value)], pos)\n    },\n  }\n}\n", "import regexpTree from 'regexp-tree'\nimport type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { any, fromRange, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nfunction firstSetFromRegex(pattern: string): { firstSet: FirstSet; canMatchNewline: boolean } {\n  try {\n    const ast = regexpTree.parse(`/${pattern}/`)\n    return extractFirstSet(ast.body as unknown as RegexNode)\n  } catch {\n    return { firstSet: any(), canMatchNewline: true }\n  }\n}\n\ntype RegexNode = {\n  type: string\n  [key: string]: unknown\n}\n\nfunction canBeEmpty(node: RegexNode | null | undefined): boolean {\n  if (!node) return true\n  switch (node.type) {\n    case 'Repetition': {\n      const q = node.quantifier as { kind: string; from?: number }\n      return q.kind === '*' || q.kind === '?' || (q.kind === 'Range' && (q.from ?? 1) === 0)\n    }\n    case 'Alternative': {\n      const exprs = node.expressions as RegexNode[]\n      return !exprs || exprs.length === 0 || exprs.every(e => canBeEmpty(e))\n    }\n    case 'Group': return canBeEmpty(node.expression as RegexNode)\n    case 'Disjunction': return canBeEmpty(node.left as RegexNode) || canBeEmpty(node.right as RegexNode)\n    default: return false\n  }\n}\n\nfunction extractFirstSet(node: RegexNode | null | undefined): { firstSet: FirstSet; canMatchNewline: boolean } {\n  if (!node) return { firstSet: empty(), canMatchNewline: false }\n\n  switch (node.type) {\n    case 'Disjunction': {\n      const left = extractFirstSet(node.left as RegexNode)\n      const right = extractFirstSet(node.right as RegexNode)\n      return {\n        firstSet: union(left.firstSet, right.firstSet),\n        canMatchNewline: left.canMatchNewline || right.canMatchNewline,\n      }\n    }\n    case 'Alternative': {\n      const exprs = node.expressions as RegexNode[]\n      if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false }\n      // Walk forward through expressions that can match empty, unioning their first-sets.\n      // This handles patterns like -?[0-9]+ where the first expr is optional.\n      let fs: FirstSet = empty()\n      let canNL = false\n      for (const expr of exprs) {\n        const r = extractFirstSet(expr)\n        fs = union(fs, r.firstSet)\n        canNL = canNL || r.canMatchNewline\n        if (!canBeEmpty(expr)) break\n      }\n      return { firstSet: fs, canMatchNewline: canNL }\n    }\n    case 'Char': {\n      const kind = node.kind as string\n      if (kind === 'simple') {\n        const code = (node.codePoint as number | undefined) ?? (node.value as string).codePointAt(0) ?? 0\n        return { firstSet: fromRange(code, code), canMatchNewline: code === 0x0a }\n      }\n      if (kind === 'meta') {\n        const val = node.value as string\n        if (val === '.') return { firstSet: any(), canMatchNewline: false }\n        if (val === 'd') return { firstSet: fromRange(0x30, 0x39), canMatchNewline: false }\n        if (val === 'D') return { firstSet: any(), canMatchNewline: true }\n        if (val === 'w') return {\n          firstSet: union(union(fromRange(0x30, 0x39), fromRange(0x41, 0x5a)),\n            union(fromRange(0x61, 0x7a), fromRange(0x5f, 0x5f))),\n          canMatchNewline: false,\n        }\n        if (val === 's') return { firstSet: fromRange(0x09, 0x0d), canMatchNewline: true }\n        if (val === 'n') return { firstSet: fromRange(0x0a, 0x0a), canMatchNewline: true }\n      }\n      return { firstSet: any(), canMatchNewline: true }\n    }\n    case 'CharacterClass': {\n      const expressions = node.expressions as RegexNode[]\n      let fs: FirstSet = empty()\n      let canNL = false\n      for (const expr of expressions) {\n        if (expr.type === 'ClassRange') {\n          const from = (expr.from as RegexNode).codePoint as number\n          const to = (expr.to as RegexNode).codePoint as number\n          fs = union(fs, fromRange(from, to))\n          if (from <= 0x0a && 0x0a <= to) canNL = true\n        } else if (expr.type === 'Char') {\n          const r = extractFirstSet(expr)\n          fs = union(fs, r.firstSet)\n          canNL = canNL || r.canMatchNewline\n        }\n      }\n      if (node.negative) return { firstSet: any(), canMatchNewline: true }\n      return { firstSet: fs, canMatchNewline: canNL }\n    }\n    case 'Repetition': {\n      return extractFirstSet(node.expression as RegexNode)\n    }\n    case 'Group': {\n      return extractFirstSet(node.expression as RegexNode)\n    }\n    default:\n      return { firstSet: any(), canMatchNewline: true }\n  }\n}\n\nfunction optimizeRegex(source: string, flags: string): string {\n  try {\n    const result = regexpTree.optimize(`/${source}/${flags}`)\n    const str = result.toString()\n    const lastSlash = str.lastIndexOf('/')\n    return str.slice(1, lastSlash)\n  } catch {\n    return source\n  }\n}\n\nexport function regex(pattern: string | RegExp, flags = ''): Combinator<string> {\n  const source = typeof pattern === 'string' ? pattern : pattern.source\n  const resolvedFlags = typeof pattern === 'string' ? flags : pattern.flags\n\n  const optimizedSource = optimizeRegex(source, resolvedFlags)\n  const anchored = new RegExp(optimizedSource, 'y' + resolvedFlags.replace(/[gy]/g, ''))\n\n  const { firstSet, canMatchNewline } = firstSetFromRegex(source)\n  const meta: ParserMeta = { firstSet, canMatchNewline, isTrivia: false }\n\n  return {\n    _tag: 'regex',\n    _meta: meta,\n    _def: { tag: 'regex', source, flags: resolvedFlags, optimizedSource },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      anchored.lastIndex = pos\n      const m = anchored.exec(input)\n      if (m === null) {\n        return failAt(ctx, [`/${source}/`], pos)\n      }\n      const span = { start: pos, end: pos + m[0]!.length }\n      const leaf = { _tag: 'leaf', value: m[0]!, span }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n      return { ok: true, value: m[0]!, span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { fromChar, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type KeywordsOptions = {\n  /** Match case-insensitively. */\n  caseInsensitive?: boolean\n  /**\n   * Character class (regex source, e.g. `'A-Za-z0-9_-'`) that must NOT follow a\n   * match \u2014 a word boundary. Prevents matching `red` inside `redish`.\n   */\n  boundary?: string\n}\n\n/**\n * Match a single keyword with an automatic word-boundary guard. Prevents\n * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,\n * which covers most programming-language identifiers.\n *\n *   word('true')              // matches \"true\" but not \"trueish\"\n *   word('color', 'A-Za-z-') // CSS-style identifier boundary\n */\nexport function word(str: string, boundary = '_0-9A-Za-z'): Combinator<string> {\n  return keywords([str], { boundary })\n}\n\n/**\n * Create a keyword factory with a fixed word-boundary class. Use when many\n * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,\n * `word(str, boundary?)` is enough; you can also roll your own factory with\n * `(s) => word(s, boundary)`.\n *\n *   const kw = makeWord()                    // default: '_0-9A-Za-z'\n *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents\n *\n *   const query = kw('query')\n *   const color = cssKw('color')             // matches \"color\" but not \"color-scheme\"\n */\nexport function makeWord(boundary = '_0-9A-Za-z'): (str: string) => Combinator<string> {\n  return (str: string) => keywords([str], { boundary })\n}\n\nfunction escapeRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Match any one of a set of fixed keywords, longest-first (so `border` wins over\n * `bord`), with an optional trailing word-boundary guard. Compiles to a single\n * sticky regex \u2014 far less error-prone than a hand-maintained alternation, and\n * the common case (keyword sets: CSS colors, units, at-rule names, HTML tags).\n *\n *   keywords(CSS_COLOR_NAMES, { caseInsensitive: true, boundary: 'A-Za-z0-9_-' })\n *\n * On success the matched text is recorded as a CSTLeaf (like literal()/regex()).\n */\nexport function keywords(words: readonly string[], opts: KeywordsOptions = {}): Combinator<string> {\n  // Longest-first keeps the alternation greedy-correct (regex alternation is\n  // first-match, not longest-match).\n  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length)\n  const alt = sorted.map(escapeRe).join('|')\n  const boundary = opts.boundary ? `(?![${opts.boundary}])` : ''\n  const flags = opts.caseInsensitive ? 'iuy' : 'uy'\n  const re = new RegExp(`(?:${alt})${boundary}`, flags)\n\n  // First-set: the set of first code points across all keywords (and their\n  // case-folded variants when case-insensitive), for choice() dispatch.\n  let firstSet: FirstSet = empty()\n  for (const w of sorted) {\n    if (w.length === 0) continue\n    const cp = w.codePointAt(0)!\n    firstSet = union(firstSet, fromChar(cp))\n    if (opts.caseInsensitive) {\n      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0)\n      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0)\n      if (u !== undefined) firstSet = union(firstSet, fromChar(u))\n      if (l !== undefined) firstSet = union(firstSet, fromChar(l))\n    }\n  }\n\n  const meta: ParserMeta = { firstSet, canMatchNewline: false, isTrivia: false }\n\n  return {\n    _tag: 'keywords',\n    _meta: meta,\n    _def: { tag: 'keywords', words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      re.lastIndex = pos\n      const m = re.exec(input)\n      if (m === null || m.index !== pos) {\n        return failAt(ctx, ['keyword'], pos)\n      }\n      const value = m[0]!\n      const span = { start: pos, end: pos + value.length }\n      const leaf = { _tag: 'leaf', value, span }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf)\n      return { ok: true, value, span }\n    },\n  }\n}\n", "import type {\n  Combinator, ParseContext, ParseResult, ParserMeta, FirstSet,\n  AutoNotCheck, CharRange, ChoiceStrategy, GatedArm,\n} from '../types.ts'\nimport { union, intersects } from './first-set.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\ntype ArmParser<T> = T extends GatedArm<infer U> ? Combinator<U> : T extends Combinator<infer U> ? Combinator<U> : never\ntype UnionArms<T extends (Combinator<unknown> | GatedArm<unknown>)[]> = {\n  [K in keyof T]: ArmParser<T[K]>\n}[number] extends Combinator<infer U> ? U : never\n\nexport function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(Combinator<unknown> | GatedArm<unknown>)[]]>(\n  ...args: T\n): Combinator<UnionArms<T>> {\n  // Unwrap gated arms into (parser, gate) pairs\n  const parsers = args.map(a => ('gate' in a ? a.combinator : a)) as Combinator<unknown>[]\n  const gates   = args.map(a => ('gate' in a ? a.gate   : null)) as (((state: unknown) => boolean) | null)[]\n\n  const hasGates = gates.some(g => g !== null)\n\n  const disjoint = !hasGates && areDisjoint(parsers.map(p => p._meta.firstSet))\n\n  let combined: FirstSet = { kind: 'empty' }\n  for (const p of parsers) combined = union(combined, p._meta.firstSet)\n\n  const meta: ParserMeta = {\n    firstSet: combined,\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n    disjoint,\n  }\n\n  // Gates force firstMatch \u2014 predicate dispatch is incompatible with first-set strategies.\n  const strategy = (disjoint || hasGates) ? null : detectStrategy(parsers)\n  const autoNot = (!disjoint && !hasGates && strategy?.tag === 'firstMatch')\n    ? computeAutoNot(parsers)\n    : parsers.map(() => null)\n\n  // Runtime state for each strategy (built once, reused on every parse call):\n  let greedyRe: RegExp | null = null\n  let greedyLitMap: Map<string, number> | null = null\n  let sortedParsers: Combinator<unknown>[] | null = null\n\n  if (strategy?.tag === 'greedyClassify') {\n    const regexDef = getCoreRegexDef(parsers[strategy.superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    greedyRe = new RegExp(regexDef.source, flags)\n    greedyLitMap = new Map()\n    for (let i = 0; i < parsers.length; i++) {\n      if (i === strategy.superIndex) continue\n      const litVal = getCoreLiteralValue(parsers[i]!)\n      if (litVal !== null) greedyLitMap.set(litVal, i)\n    }\n  } else if (strategy?.tag === 'literalsLongestFirst') {\n    sortedParsers = strategy.sortedIndices.map(i => parsers[i]!)\n  }\n\n  return {\n    _tag: 'choice',\n    _meta: meta,\n    _def: {\n      tag: 'choice',\n      parsers,\n      gates,\n      disjoint,\n      strategy: strategy ?? { tag: 'firstMatch' },\n      autoNot,\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnionArms<T>> {\n      const expected: string[] = []\n\n      // \u2500\u2500 Disjoint: O(1) first-char dispatch (never has gates) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      if (disjoint && pos < input.length) {\n        const code = input.codePointAt(pos)!\n        for (const parser of parsers) {\n          if (inFirstSet(code, parser._meta.firstSet)) {\n            const result = parser.parse(input, pos, ctx)\n            if (result.ok) return result as ParseResult<UnionArms<T>>\n            expected.push(...result.expected)\n            return { ok: false, expected, span: { start: pos, end: pos } }\n          }\n        }\n        return {\n          ok: false,\n          expected: parsers.flatMap(p => {\n            const r = p.parse(input, pos, ctx)\n            return r.ok ? [] : r.expected\n          }),\n          span: { start: pos, end: pos },\n        }\n      }\n\n      // \u2500\u2500 greedyClassify: run one regex, classify by string equality \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //    One parse call total. No backtracking.\n      if (strategy?.tag === 'greedyClassify') {\n        const superResult = parsers[strategy.superIndex]!.parse(input, pos, ctx)\n        if (!superResult.ok) return superResult as ParseResult<UnionArms<T>>\n\n        const end = superResult.span.end\n        const litIdx = greedyLitMap!.get(input.slice(pos, end))\n        if (litIdx !== undefined) {\n          const litVal = getCoreLiteralValue(parsers[litIdx]!)!\n          const value = applyTransforms(parsers[litIdx]!, litVal, { start: pos, end })\n          return { ok: true, value: value as UnionArms<T>, span: { start: pos, end } }\n        }\n        return superResult as ParseResult<UnionArms<T>>\n      }\n\n      // \u2500\u2500 literalsLongestFirst: sorted descending by length, no backtracking \u2500\n      if (strategy?.tag === 'literalsLongestFirst') {\n        for (const p of sortedParsers!) {\n          const r = p.parse(input, pos, ctx)\n          if (r.ok) return r as ParseResult<UnionArms<T>>\n          expected.push(...r.expected)\n        }\n        return { ok: false, expected, span: { start: pos, end: pos } }\n      }\n\n      // \u2500\u2500 firstMatch (+ gated arms): try each arm in order, skipping gated-off arms \u2500\u2500\n      for (let i = 0; i < parsers.length; i++) {\n        if (gates[i] && !gates[i]!(ctx.state)) continue   // gate blocks this arm\n        // Save leaf-array lengths so a failed/rejected arm can be rolled back.\n        const mark = saveCstMark(ctx)\n        const logLen = ctx._triviaLog?.length\n        const result = parsers[i]!.parse(input, pos, ctx)\n        if (!result.ok) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          expected.push(...result.expected)\n          continue\n        }\n        const checks = autoNot[i]\n        if (checks && autoNotFires(input, result.span.end, checks)) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          continue\n        }\n        return result as ParseResult<UnionArms<T>>\n      }\n      return { ok: false, expected, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Strategy detection\n// ---------------------------------------------------------------------------\n\nfunction detectStrategy(parsers: Combinator<unknown>[]): ChoiceStrategy {\n  // greedyClassify: exactly one regex arm whose regex matches every literal arm's\n  // value exactly (and can potentially match more). All other arms must be literals.\n  const regexIndices: number[] = []\n  const literalIndices: number[] = []\n  for (let i = 0; i < parsers.length; i++) {\n    if (getCoreRegexDef(parsers[i]!) !== null) regexIndices.push(i)\n    else if (getCoreLiteralValue(parsers[i]!) !== null) literalIndices.push(i)\n  }\n\n  if (\n    regexIndices.length === 1 &&\n    literalIndices.length === parsers.length - 1 &&\n    literalIndices.length > 0\n  ) {\n    const superIndex = regexIndices[0]!\n    const regexDef = getCoreRegexDef(parsers[superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    const re = new RegExp(regexDef.source, flags)\n    const allSubsumed = literalIndices.every(i => {\n      const litVal = getCoreLiteralValue(parsers[i]!)!\n      re.lastIndex = 0\n      const m = re.exec(litVal)\n      return m !== null && m[0] === litVal\n    })\n    if (allSubsumed) return { tag: 'greedyClassify', superIndex }\n  }\n\n  // literalsLongestFirst: every arm is a literal \u2014 try longest first, no backtracking\n  if (parsers.length === literalIndices.length) {\n    const sortedIndices = [...literalIndices].sort((a, b) =>\n      getCoreLiteralValue(parsers[b]!)!.length - getCoreLiteralValue(parsers[a]!)!.length\n    )\n    return { tag: 'literalsLongestFirst', sortedIndices }\n  }\n\n  return { tag: 'firstMatch' }\n}\n\n// ---------------------------------------------------------------------------\n// Auto-not analysis (firstMatch fallback only)\n// ---------------------------------------------------------------------------\n\nfunction computeAutoNot(parsers: Combinator<unknown>[]): (AutoNotCheck[] | null)[] {\n  return parsers.map((p, i) => {\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) return null\n\n    const checks: AutoNotCheck[] = []\n    for (let j = i + 1; j < parsers.length; j++) {\n      const other = parsers[j]!\n      const otherLit = getCoreLiteralValue(other)\n      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {\n        checks.push({ kind: 'startsWith', value: otherLit.slice(litVal.length) })\n        continue\n      }\n      const regexDef = getCoreRegexDef(other)\n      if (regexDef !== null) {\n        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags)\n        if (contSet !== null) checks.push({ kind: 'firstSet', set: contSet })\n      }\n    }\n    return checks.length > 0 ? checks : null\n  })\n}\n\nfunction autoNotFires(input: string, end: number, checks: AutoNotCheck[]): boolean {\n  for (const check of checks) {\n    if (check.kind === 'firstSet') {\n      const code = end < input.length ? (input.codePointAt(end) ?? -1) : -1\n      if (inFirstSet(code, check.set)) return true\n    } else {\n      if (input.startsWith(check.value, end)) return true\n    }\n  }\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// Helpers: unwrap transform/sequence wrappers\n// ---------------------------------------------------------------------------\n\n/** Walk transform wrappers to find an inner literal's string value. */\nexport function getCoreLiteralValue(p: Combinator<unknown>): string | null {\n  const def = p._def\n  if (def.tag === 'literal' && !def.caseInsensitive) return def.value\n  if (def.tag === 'transform') return getCoreLiteralValue(def.parser)\n  return null\n}\n\n/** Walk transform wrappers to find an inner regex's source/flags. */\nexport function getCoreRegexDef(p: Combinator<unknown>): { source: string; flags: string } | null {\n  const def = p._def\n  if (def.tag === 'regex') return { source: def.source, flags: def.flags }\n  if (def.tag === 'transform') return getCoreRegexDef(def.parser)\n  if (def.tag === 'label') return getCoreRegexDef(def.parser)\n  return null\n}\n\n/**\n * Apply a parser's transform chain to an already-known value, without re-parsing.\n * Used by greedyClassify to avoid a second parse call for the winning literal arm.\n */\nfunction applyTransforms(p: Combinator<unknown>, value: unknown, span: { start: number; end: number }): unknown {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const inner = applyTransforms(def.parser, value, span)\n    return def.fn(inner, span)\n  }\n  return value\n}\n\n// ---------------------------------------------------------------------------\n// Continuation first-set (for firstMatch auto-not analysis)\n// ---------------------------------------------------------------------------\n\nfunction continuationFirstSet(lit: string, source: string, flags: string): FirstSet | null {\n  const re = new RegExp(source, 'y' + flags.replace(/[gy]/g, ''))\n  re.lastIndex = 0\n  const base = re.exec(lit)\n  if (!base || base[0] !== lit) return null\n\n  const contCodes: number[] = []\n  for (let code = 1; code < 128; code++) {\n    re.lastIndex = 0\n    const m = re.exec(lit + String.fromCharCode(code))\n    if (m && m[0].length > lit.length) contCodes.push(code)\n  }\n  if (contCodes.length === 0) return null\n  return codesToFirstSet(contCodes)\n}\n\nfunction codesToFirstSet(codes: number[]): FirstSet {\n  codes.sort((a, b) => a - b)\n  const ranges: CharRange[] = []\n  let lo = codes[0]!, hi = codes[0]!\n  for (let i = 1; i < codes.length; i++) {\n    if (codes[i] === hi + 1) { hi = codes[i]! }\n    else { ranges.push({ lo, hi }); lo = hi = codes[i]! }\n  }\n  ranges.push({ lo, hi })\n  return { kind: 'ranges', ranges }\n}\n\nfunction inFirstSet(code: number, fs: FirstSet): boolean {\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nfunction areDisjoint(sets: FirstSet[]): boolean {\n  if (sets.some(s => s.kind === 'any')) return false\n  for (let i = 0; i < sets.length; i++)\n    for (let j = i + 1; j < sets.length; j++)\n      if (intersects(sets[i]!, sets[j]!)) return false\n  return true\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport { pushCstTriviaEntry, pushTriviaLogEntry } from './capture-buffer.ts'\n\nexport type TriviaChunk = { start: number; end: number; kindIndex: number }\n\nexport type LabeledTriviaSpec = {\n  readonly labels: readonly string[]\n  readonly arms: ReadonlyArray<{ label: string; kindIndex: number; parser: Combinator<unknown> }>\n  readonly minRepeats: number\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\n/** Strip `label()` wrapper; returns inner parser for matching. */\nexport function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {\n  if (p._def.tag === 'label') return { label: p._def.label, parser: p._def.parser }\n  return null\n}\n\n/**\n * When every trivia arm is `label(name, parser)` inside `oneOrMore(choice(\u2026))`\n * (or a single labeled arm), return the label table and matchers.\n */\nexport function analyzeLabeledTrivia(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  let core = unwrapTrivia(trivia)\n  let minRepeats = 1\n\n  if (core._def.tag === 'oneOrMore') {\n    core = core._def.parser\n    minRepeats = 1\n  } else if (core._def.tag === 'many') {\n    core = core._def.parser\n    minRepeats = 0\n  }\n\n  const arms: LabeledTriviaSpec['arms'][number][] = []\n\n  if (core._def.tag === 'choice') {\n    for (let i = 0; i < core._def.parsers.length; i++) {\n      const peeled = peelLabel(core._def.parsers[i]!)\n      if (!peeled) return null\n      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser })\n    }\n  } else {\n    const peeled = peelLabel(core)\n    if (!peeled) return null\n    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser })\n  }\n\n  return { labels: arms.map(a => a.label), arms, minRepeats }\n}\n\n/** Label table on a `trivia()` combinator, if all arms are labeled. */\nexport function triviaKindLabels(trivia: Combinator<unknown> | undefined): readonly string[] | undefined {\n  if (!trivia) return undefined\n  const fromMeta = trivia._meta.triviaKindLabels\n  if (fromMeta) return fromMeta\n  return analyzeLabeledTrivia(trivia)?.labels\n}\n\nfunction matchArmAt(\n  input: string,\n  pos: number,\n  arm: Combinator<unknown>,\n): { end: number } | null {\n  const r = arm.parse(input, pos, { trackLines: false })\n  if (!r.ok || r.span.end <= pos) return null\n  return { end: r.span.end }\n}\n\n/**\n * Scan maximal labeled trivia chunks (PEG `oneOrMore(choice(\u2026))` semantics).\n * Each successful arm match becomes one entry with that arm's kind index.\n */\nexport function scanLabeledTriviaChunks(\n  input: string,\n  cur: number,\n  spec: LabeledTriviaSpec,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    let matched: { end: number; kindIndex: number } | null = null\n    for (const arm of spec.arms) {\n      const m = matchArmAt(input, pos, arm.parser)\n      if (m) {\n        matched = { end: m.end, kindIndex: arm.kindIndex }\n        break\n      }\n    }\n    if (!matched) break\n    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex })\n    pos = matched.end\n  }\n\n  if (chunks.length < spec.minRepeats) {\n    return { end: cur, chunks: [] }\n  }\n  return { end: pos, chunks }\n}\n\n/** Hand-rolled ws / block-comment scan with per-chunk kind indices (interpreter). */\nexport function scanFastWsCommentsChunks(\n  input: string,\n  cur: number,\n  wsKind: number,\n  commentKind: number,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    const c = input.charCodeAt(pos)\n    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {\n      const start = pos\n      pos++\n      while (pos < input.length) {\n        const c2 = input.charCodeAt(pos)\n        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++\n        else break\n      }\n      chunks.push({ start, end: pos, kindIndex: wsKind })\n      continue\n    }\n    if (c === 47 && input.charCodeAt(pos + 1) === 42) {\n      const start = pos\n      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      pos = j + 2 <= input.length ? j + 2 : input.length\n      chunks.push({ start, end: pos, kindIndex: commentKind })\n      continue\n    }\n    break\n  }\n\n  return { end: pos, chunks }\n}\n\n/** Fast scan when trivia is labeled ws + block-comment (CSS `rw`). */\nexport function tryFastLabeledScan(\n  input: string,\n  cur: number,\n  trivia: Combinator<unknown>,\n): { end: number; chunks: TriviaChunk[] } | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec || spec.arms.length !== 2) return null\n\n  const wsArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && !src.includes('\\\\*')\n  })\n  const commentArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && src.includes('\\\\*')\n  })\n  if (!wsArm || !commentArm) return null\n\n  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] }\n  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n}\n\nexport function recordTriviaChunks(ctx: ParseContext, chunks: readonly TriviaChunk[]): void {\n  const kinds = ctx.triviaKindLabels\n  for (const ch of chunks) {\n    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    if (ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)) {\n      pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    }\n  }\n}\n", "import type { ParseContext } from '../types.ts'\nimport {\n  analyzeLabeledTrivia,\n  recordTriviaChunks,\n  scanLabeledTriviaChunks,\n  tryFastLabeledScan,\n} from '../cst/trivia-kinds.ts'\nimport {\n  pushCstTriviaEntry,\n  pushTriviaLogEntry,\n  rollbackCstCapture,\n  saveCstMark,\n} from '../cst/capture-buffer.ts'\n\n/**\n * Result of scanning trivia: the position after it, plus a `commit()` that\n * records the matched trivia tokens into the active rawChildren collector.\n * Recording is deferred so callers that may reject the following item (e.g.\n * many()/oneOrMore() retries) can advance speculatively without recording\n * trivia that doesn't actually sit between two accepted items.\n */\nexport type TriviaScan = { end: number; commit: () => void }\n\n/** Saved lengths for rolling back speculative trivia commits. */\nexport type TriviaRollbackMark = { raw: number; tlog: number; leaves: number; log: number }\n\nconst NOOP_COMMIT = () => {}\n\n/** True when trivia recording must be deferred until the following term commits. */\nexport function needsDeferredTriviaCommit(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n\nexport function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark {\n  const m = saveCstMark(ctx)\n  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, log: ctx._triviaLog ? ctx._triviaLog.length : 0 }\n}\n\nexport function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void {\n  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves })\n  if (ctx._triviaLog) ctx._triviaLog.length = mark.log\n}\n\nfunction scanWithLabels(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia!\n  const spec = analyzeLabeledTrivia(triviaP)\n  if (!spec) return { end: cur, commit: NOOP_COMMIT }\n\n  const fast = tryFastLabeledScan(input, cur, triviaP)\n  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec)\n  if (end === cur) return { end: cur, commit: NOOP_COMMIT }\n\n  return {\n    end,\n    commit: () => recordTriviaChunks(ctx, chunks),\n  }\n}\n\n/**\n * Skip trivia at `cur` and return the new position. No recording, no wrapper\n * object \u2014 use between sequence/repeat terms when CST trivia capture is off.\n */\nexport function advanceTrivia(input: string, cur: number, ctx: ParseContext): number {\n  const triviaP = ctx.trivia\n  if (!triviaP) return cur\n  if (ctx.triviaKindLabels) {\n    const scan = scanWithLabels(input, cur, ctx)\n    return scan.end\n  }\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return tr.ok && tr.span.end > cur ? tr.span.end : cur\n}\n\n/**\n * Scan trivia at `cur` using `ctx.trivia`, WITHOUT recording it. Returns the\n * position after the trivia (or `cur` if none) and a `commit()` to record it.\n */\nexport function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia\n  if (!triviaP) return { end: cur, commit: NOOP_COMMIT }\n\n  const log = ctx._triviaLog\n  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)\n\n  if (ctx.triviaKindLabels && (log !== undefined || captureTl)) {\n    return scanWithLabels(input, cur, ctx)\n  }\n\n  if (log !== undefined || captureTl) {\n    const tr = triviaP.parse(input, cur, {\n      trackLines: log !== undefined ? false : ctx.trackLines,\n      state: ctx.state,\n    })\n    if (!tr.ok || tr.span.end === cur) return { end: cur, commit: NOOP_COMMIT }\n    const end = tr.span.end\n    return {\n      end,\n      commit: () => {\n        pushTriviaLogEntry(ctx, cur, end)\n        if (captureTl) pushCstTriviaEntry(ctx, cur, end)\n      },\n    }\n  }\n\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT }\n}\n\n/**\n * Consume trivia at `cur`, recording it immediately. For callers that always\n * accept the trivia between two committed terms (e.g. sequence/sepBy).\n */\nexport function consumeTrivia(input: string, cur: number, ctx: ParseContext): number {\n  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx)\n  const scan = scanTrivia(input, cur, ctx)\n  scan.commit()\n  return scan.end\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'\nimport { empty } from './first-set.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\n\ntype UnwrapParsers<T extends Combinator<unknown>[]> = {\n  [K in keyof T]: T[K] extends Combinator<infer U> ? U : never\n}\n\nexport function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[]]>(\n  ...parsers: T\n): Combinator<UnwrapParsers<T>> {\n  const meta: ParserMeta = {\n    firstSet: parsers[0]?._meta.firstSet ?? empty(),\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'sequence',\n    _meta: meta,\n    _def: { tag: 'sequence', parsers: parsers as Combinator<unknown>[] },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n      const values: unknown[] = []\n      let cur = pos\n\n      for (let i = 0; i < parsers.length; i++) {\n        if (ctx.trivia && i > 0) {\n          // Skip trivia between terms, but only *consume* it for span purposes if\n          // this term actually matches content past the trivia. A term that matches\n          // empty (optional/many/lookahead) leaves the trivia for the enclosing rule.\n          let scanEnd: number\n          let mark = saveTriviaMark(ctx)\n\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) {\n            cur = result.span.end\n          } else {\n            rollbackTrivia(ctx, mark)\n          }\n          values.push(result.value)\n          continue\n        }\n\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        values.push(result.value)\n        cur = result.span.end\n      }\n\n      return {\n        ok: true,\n        value: values as UnwrapParsers<T>,\n        span: { start: pos, end: cur },\n      }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\n\n/**\n * Parse one repetition item at `cur`, first skipping (and, in capture mode,\n * recording) any leading trivia \u2014 so a repeating combinator consumes the trivia\n * between items uniformly, the way advancing the index always should. Trivia is\n * committed *before* the item so rawChildren order stays [item, trivia, item];\n * if the item then fails or makes no progress the trivia is rolled back and the\n * loop stops (the trivia is trailing and belongs to the enclosing context).\n *\n * Returns the item value + end position, the underlying failure (so oneOrMore\n * can propagate a first-item failure), or 'stop'.\n */\nfunction repItem<T>(\n  combinator: Combinator<T>,\n  input: string,\n  cur: number,\n  ctx: ParseContext\n): { value: T; end: number } | { fail: ParseResult<T> } | 'stop' {\n  const mark = saveTriviaMark(ctx)\n  let pos = cur\n  if (ctx.trivia) {\n    if (needsDeferredTriviaCommit(ctx)) {\n      const scan = scanTrivia(input, cur, ctx)\n      scan.commit()\n      pos = scan.end\n    } else {\n      pos = advanceTrivia(input, cur, ctx)\n    }\n  }\n  // Nothing but trivia left: don't speculatively parse an item at EOF (it would\n  // fail and could trigger an item's recover()/error side-effects). The trivia\n  // is trailing \u2014 roll it back for the enclosing context and stop.\n  if (pos >= input.length) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  const result = combinator.parse(input, pos, ctx)\n  if (!result.ok) {\n    rollbackTrivia(ctx, mark)\n    return { fail: result }\n  }\n  if (result.span.end === pos) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  return { value: result.value, end: result.span.end }\n}\n\nexport function many<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'many',\n    _meta: meta,\n    _def: { tag: 'many', parser: combinator as Combinator<unknown>, min: 0 },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const values: T[] = []\n      let cur = pos\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop' || 'fail' in item) break\n        values.push(item.value)\n        cur = item.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'oneOrMore',\n    _meta: meta,\n    _def: { tag: 'oneOrMore', parser: combinator as Combinator<unknown>, min: 1 },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // First item is mandatory (parsed at pos directly \u2014 leading trivia is the\n      // enclosing context's responsibility); subsequent items skip leading trivia.\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return first\n      const values: T[] = [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop' || 'fail' in item) break\n        values.push(item.value)\n        cur = item.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function optional<T>(combinator: Combinator<T>): Combinator<T | null> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'optional',\n    _meta: meta,\n    _def: { tag: 'optional', parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {\n      const mark = saveTriviaMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T>\n      // Inner failed \u2192 roll back any CST leaves/trivia it captured before giving up.\n      rollbackTrivia(ctx, mark)\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n\nexport function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'sepBy',\n    _meta: meta,\n    _def: { tag: 'sepBy', parser: combinator as Combinator<unknown>, separator: separator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return { ok: true, value: [], span: { start: pos, end: pos } }\n      const values: T[] = [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        // One mark for the whole iteration (separator + following item): if the\n        // item fails, the trailing separator must be rolled back with it, or its\n        // captured leaves leak past the end of the list.\n        const loopMark = saveTriviaMark(ctx)\n        let sepPos = cur\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            sepPos = scan.end\n          } else {\n            sepPos = advanceTrivia(input, cur, ctx)\n          }\n        }\n        const sep = separator.parse(input, sepPos, ctx)\n        if (!sep.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        let nextPos = sep.span.end\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, sep.span.end, ctx)\n            scan.commit()\n            nextPos = scan.end\n          } else {\n            nextPos = advanceTrivia(input, sep.span.end, ctx)\n          }\n        }\n        const next = combinator.parse(input, nextPos, ctx)\n        if (!next.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        values.push(next.value)\n        cur = next.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Create a forward-declared parser slot for mutually recursive grammars.\n *\n * Because JS evaluates arguments eagerly, you can't reference a variable\n * before it's declared. ref() creates a placeholder you fill in later:\n *\n *   const value = ref<JSONValue>()\n *   const array  = transform(sequence(literal('['), sepBy(value, literal(',')), literal(']')), ...)\n *   const object = transform(sequence(literal('{'), sepBy(pair, literal(',')), literal('}')), ...)\n *   value.define(choice(object, array, string, number, bool, nullVal))\n *\n * Unlike lazy(() => x), you use the ref directly \u2014 no wrapping at each call site.\n */\nexport function ref<T>(): Combinator<T> & { define(p: Combinator<T>): void } {\n  let resolved: Combinator<T> | null = null\n\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  const slot = {\n    _tag: 'lazy' as const,\n    _meta: meta,\n    _def: {\n      tag: 'lazy' as const,\n      thunk: () => {\n        if (!resolved) throw new Error('ref<T>() used before .define() was called')\n        return resolved as Combinator<unknown>\n      },\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      if (!resolved) throw new Error('ref<T>() used before .define() was called')\n      return resolved.parse(input, pos, ctx)\n    },\n    define(p: Combinator<T>): void {\n      if (resolved) throw new Error('ref<T>() already defined')\n      resolved = p\n    },\n  }\n\n  return slot\n}\n", "import type { Combinator } from '../types.ts'\nimport { ref } from './ref.ts'\n\n/**\n * Define named grammar rules without forward declarations.\n *\n * Pass a factory that receives all rule names as references (via a Proxy)\n * and returns a record of combinators. rules() handles creating ref()\n * placeholders and wiring them up \u2014 the user never sees ref() at all.\n *\n *   const { value } = rules(g => ({\n *     value:  choice(g.object, g.array, str, num, bool, nil),\n *     object: transform(sequence('{', sepBy(g.pair, ','), '}'), Object.fromEntries),\n *     array:  transform(sequence('[', sepBy(g.value, ','), ']'), ([, items]) => items),\n *     pair:   transform(sequence(g.key, literal(':'), g.value), ([k,, v]) => [k, v]),\n *   }))\n *\n * Not every name in the factory must appear in the returned object \u2014 local helpers\n * (like `comma`, `key`) can be plain const inside the factory and composed normally.\n * Only names that OTHER rules reference via `g.xxx` need to be in the returned record.\n *\n * TypeScript: use an explicit type parameter for full type safety on `g`:\n *   rules<{ value: Combinator<JSONValue>; array: Combinator<JSONValue[]> }>(g => ({ ... }))\n * Without it, `g.*` accesses are typed as `any` but the return is still inferred.\n */\nexport function rules<T extends Record<string, Combinator<unknown>>>(\n  factory: (self: any) => T\n): T {\n  const cache: Partial<T> = {}\n\n  // Proxy: accessing any property creates a ref() placeholder on first touch.\n  const proxy = new Proxy(cache, {\n    get(target, key) {\n      if (typeof key !== 'string') return undefined\n      const record = target as Record<string, Combinator<unknown>>\n      if (!(key in record)) {\n        record[key] = ref()\n      }\n      return record[key]\n    },\n  })\n\n  // Evaluate all rule definitions. JavaScript evaluates object-literal values\n  // left-to-right, so any `g.ruleName` access inside triggers placeholder creation\n  // before the rule's own parser is built \u2014 enabling forward references.\n  const definitions = factory(proxy)\n\n  // Fill each ref with its actual definition, or store directly if never accessed via proxy.\n  for (const key of Object.keys(definitions)) {\n    const placeholder = (cache as Record<string, Combinator<unknown>>)[key]\n    const parser = (definitions as Record<string, Combinator<unknown>>)[key]!\n    if (placeholder !== undefined && typeof (placeholder as any).define === 'function') {\n      ;(placeholder as any).define(parser)\n      // Propagate actual first-set so later choices wrapping this ref get correct dispatch.\n      placeholder._meta.firstSet = parser._meta.firstSet\n      placeholder._meta.canMatchNewline = parser._meta.canMatchNewline\n    } else {\n      ;(cache as Record<string, Combinator<unknown>>)[key] = parser\n    }\n  }\n\n  return cache as T\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Negative lookahead. Succeeds (consuming nothing) when `combinator` fails;\n * fails when `combinator` succeeds.\n *\n * The standard way to match a keyword without also matching the prefix\n * of a longer identifier:\n *\n *   const kwTrue = sequence(literal('true'), not(regex(/\\w/)))\n *   // matches \"true\" in \"true && x\" but NOT in \"trueish\" or \"trueness\"\n */\nexport function not(combinator: Combinator<unknown>): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: any(),     // we don't know what NOT matches\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'not',\n    _meta: meta,\n    _def: { tag: 'not', parser: combinator },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) {\n        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } }\n      }\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\n\n/**\n * A CST/AST node rule. Runs `combinator` while collecting its terminals into\n * `children` / `rawChildren` arrays and trivia spans into `triviaLog`, then\n * calls `build(children, rawChildren, span, triviaLog)` to produce the node.\n *\n *   - `children`    \u2014 structural items in source order: spanned CSTLeaf terminals\n *                     and sub-nodes (whatever `build` returned for inner nodes).\n *   - `rawChildren` \u2014 structural children only (same items as `children`).\n *   - `triviaLog`   \u2014 flat log of trivia entries: each entry is `[start, end, insertIdx]`\n *                     consumed between terms. `insertIdx` is the rawChildren index\n *                     before which the trivia was consumed. Use `buildTriviaIndex`\n *                     to turn this into a before/after lookup table.\n *\n * If `build` returns a non-node value (e.g. a bare string for a collapsed rule),\n * the parent records it as a spanned leaf so its source span is still recoverable.\n */\nexport type BuildNode<N> = (\n  children: ReadonlyArray<unknown>,\n  rawChildren: ReadonlyArray<unknown>,\n  span: { start: number; end: number },\n  triviaLog: readonly number[],\n  state: unknown,\n) => N\n\nexport function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>): Combinator<N> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: { tag: 'node', type, parser: combinator, build },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      const r = combinator.parse(input, pos, ctx)\n      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved)\n\n      if (!r.ok) return r\n\n      const state = ctx.state !== undefined\n        ? Object.assign({}, ctx.state as Record<string, unknown>)\n        : undefined\n      const built = build(children, rawChildren, r.span, triviaLog, state)\n      const isNodeLike = typeof built === 'object' && built !== null && (built as { _tag?: string })._tag === 'node'\n      const rawEntry = isNodeLike\n        ? built\n        : { _tag: 'leaf', value: typeof built === 'string' ? built : '', span: r.span }\n      if (saved.buf !== undefined || saved.ch !== undefined) {\n        pushCstChild(ctx, built, rawEntry)\n      }\n      return { ok: true, value: built, span: r.span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\n\nexport function transform<T, U>(\n  combinator: Combinator<T>,\n  fn: (value: T, span: { start: number; end: number }) => U\n): Combinator<U> {\n  return {\n    _tag: 'transform',\n    _meta: combinator._meta,\n    _def: { tag: 'transform', parser: combinator as Combinator<unknown>, fn: fn as (v: unknown, span: { start: number; end: number }) => unknown },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<U> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      return { ...result, value: fn(result.value, result.span) }\n    },\n  }\n}\n\nexport function skip<T, S>(main: Combinator<T>, skipped: Combinator<S>): Combinator<T> {\n  return {\n    _tag: 'skip',\n    _meta: main._meta,\n    _def: { tag: 'skip', main: main as Combinator<unknown>, skipped: skipped as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = main.parse(input, pos, ctx)\n      if (!result.ok) return result\n      const s = skipped.parse(input, result.span.end, ctx)\n      if (!s.ok) return result\n      return { ...result, span: { start: result.span.start, end: s.span.end } }\n    },\n  }\n}\n\nexport function trivia<T>(combinator: Combinator<T>): Combinator<T> {\n  const kindLabels = analyzeLabeledTrivia(combinator as Combinator<unknown>)?.labels\n  return {\n    _tag: combinator._tag,\n    _meta: {\n      ...combinator._meta,\n      isTrivia: true,\n      ...(kindLabels ? { triviaKindLabels: kindLabels } : {}),\n    },\n    _def: { tag: 'trivia', parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n\n/**\n * Attach a string label to a parser arm (e.g. trivia `choice` branches).\n * Parse behavior is unchanged; the label is metadata for tooling and future\n * trivia-kind capture (`'whitespace'`, `'blockComment'`, \u2026).\n */\nexport function label<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'label', label: name, parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset\u2192line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParseFail } from '../types.ts'\nimport { buildLineIndex, annotateSpan } from '../compiler/line-index.ts'\n\nexport type ParseOptions = {\n  trackLines?: boolean\n  /**\n   * Enable error recovery. When true, recover() nodes collect their ParseErrors\n   * into a side-channel array rather than (only) embedding them in the value tree.\n   * The returned ParseOk will have an `errors` field listing all recovered errors.\n   * Top-level parse failures (where no recover() node caught the error) still\n   * return ParseFail as usual.\n   */\n  recover?: boolean\n}\n\nexport type ParserOptions = ParseOptions & {\n  /**\n   * Trivia parser for this scope. Three states:\n   *   - a Combinator \u2192 skip this trivia between sequence/repeat terms\n   *   - `undefined`  \u2192 inherit the enclosing scope's trivia (no change)\n   *   - `null`       \u2192 CLEAR trivia: no trivia skipped, so terms must be contiguous.\n   *                    Re-enable inside a nested region with another parser({ trivia }).\n   */\n  trivia?: Combinator<unknown> | null\n  /** Record consumed trivia as CSTTrivia tokens in rawChildren. Default: skip. */\n  captureTrivia?: boolean\n}\n\nexport interface ParsemanParser<T> extends Combinator<T> {\n  parse(input: string): ParseResult<T>\n  parse(input: string, pos: number, ctx: ParseContext): ParseResult<T>\n}\n\nexport function parser<T>(opts: ParserOptions, root: Combinator<T>): ParsemanParser<T> {\n  const clearTrivia = opts.trivia === null\n  return {\n    _tag: 'grammar',\n    _meta: root._meta,\n    _def: {\n      tag: 'grammar',\n      parser: root as Combinator<unknown>,\n      triviaParser: clearTrivia ? undefined : (opts.trivia ?? undefined),\n      clearTrivia,\n      trackLines: opts.trackLines ?? false,\n    },\n    parse(input: string, pos?: number, _ctx?: ParseContext): ParseResult<T> {\n      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false\n      // Preserve any CST collectors / capture flag from the caller (e.g. an\n      // enclosing node()), layering this grammar's trivia on top. Without this,\n      // a parser() nested inside a node() would drop the node's child collectors.\n      const ctx: ParseContext = {\n        ..._ctx,\n        trackLines,\n        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.\n        ...(clearTrivia ? {\n          trivia: undefined,\n          triviaKindLabels: undefined,\n        } : opts.trivia != null ? {\n          trivia: opts.trivia,\n          ...(opts.trivia._meta.triviaKindLabels\n            ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels }\n            : {}),\n        } : {}),\n        ...(opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}),\n      }\n      const result = root.parse(input, pos ?? 0, ctx)\n      if (trackLines) {\n        const idx = buildLineIndex(input)\n        return { ...result, span: annotateSpan(result.span, idx) }\n      }\n      return result\n    },\n  } as ParsemanParser<T>\n}\n\n/**\n * Run `root` with the active trivia cleared \u2014 no trivia is skipped between its\n * sequence/repeat terms, so they must be contiguous in the input. (Trivia is\n * whatever parser({ trivia }) installed \u2014 often whitespace/comments, but it is\n * grammar-defined.) The inverse of parser({ trivia }); re-enable trivia in a\n * nested region with another parser({ trivia }).\n *\n * Wrap the WHOLE contiguous run: an enclosing sequence skips trivia *before* a\n * term runs, so wrapping just the inner part would let leading trivia through.\n *\n * For a static glued token just use one literal/regex; reach for noTrivia when a\n * glued part is a structured sub-rule \u2014 e.g. a head glued to a `[subscript]`\n * whose interior still allows trivia. Turn trivia back on for a region by nesting\n * another parser({ trivia }) (innermost wins, reverts on exit); put the WHOLE\n * spaced region \u2014 including its leading `[` \u2014 inside it, since sequence skips\n * trivia only between terms, not before its first:\n *\n *   // `arr[i + 1]` \u2014 `arr` touches `[`, but the subscript is a spaced expr:\n *   noTrivia(sequence(name,\n *     parser({ trivia: ws }, sequence(literal('['), expr, literal(']')))))\n */\nexport function noTrivia<T>(root: Combinator<T>): ParsemanParser<T> {\n  return parser({ trivia: null }, root)\n}\n\nexport function parse<T>(\n  combinator: Combinator<T>,\n  input: string,\n  opts: ParseOptions = {}\n): ParseResult<T> {\n  const trackLines = opts.trackLines ?? false\n  const _errors = opts.recover ? [] : undefined\n  // In recovery mode also track the furthest-position failure, so the caller can\n  // report \"where it got stuck + what was expected\" even when a permissive top\n  // rule succeeds with unconsumed trailing input. Off by default (it adds\n  // bookkeeping to every failed alternative).\n  const _probe = opts.recover ? { offset: input.length, best: null as ParseFail | null } : undefined\n  const ctx: ParseContext = {\n    trackLines,\n    ...(_errors !== undefined ? { _errors } : {}),\n    ...(_probe !== undefined ? { _probe } : {}),\n  }\n  const result = combinator.parse(input, 0, ctx)\n  if (!result.ok) return result\n  const withErrors = _errors !== undefined\n    ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null }\n    : result\n  if (trackLines) {\n    const idx = buildLineIndex(input)\n    return { ...withErrors, span: annotateSpan(withErrors.span, idx) }\n  }\n  return withErrors\n}\n", "/**\n * Structural recognition of \"scannable\" parser arms \u2014 regex shapes that lower to\n * a tight character-scan loop instead of `regex.exec` / combinator dispatch. Each\n * shape is derived from the regex STRUCTURE, not from any hardcoded knowledge\n * that a given regex \"is whitespace\" or \"is a comment\":\n *\n *   [X]+ / [X]*            \u2192 run while the char \u2208 X                (chars)\n *   <lit>[^X]*             \u2192 consume <lit>, run until char \u2208 X     (until)\n *   <open>(?:\u2026)*<close>    \u2192 consume <open>, run to <close> literal (delimited)\n *\n * A `oneOrMore(choice(a, b, \u2026))` where every arm is one of these compiles to a\n * single char-dispatch loop with one branch per arm \u2014 any count/order, because\n * the shapes dispatch on their first 1\u20132 chars and are checked in turn. Trivia\n * (whitespace + comments) is just the value-discarded instance of this; nothing\n * here is trivia-specific.\n */\n\nexport type ScanShape =\n  | { kind: 'chars'; ranges: Array<[number, number]> }\n  | { kind: 'until'; open: number[]; stop: Array<[number, number]> }\n  | { kind: 'delimited'; open: number[]; close: number[] }\n\nconst CLASS_ESCAPES: Record<string, number> = { t: 9, n: 10, r: 13, f: 12, v: 11, '0': 0 }\nconst META = new Set('()[]{}*+?|^$.'.split(''))\n\n/** Parse a regex char-class body (chars between `[` and `]`) to code-point ranges. */\nfunction parseClassRanges(body: string): Array<[number, number]> | null {\n  const ranges: Array<[number, number]> = []\n  let i = 0\n  const readCp = (): number | null => {\n    const ch = body[i]\n    if (ch === undefined) return null\n    if (ch === '\\\\') {\n      const e = body[i + 1]\n      if (e === undefined) return null\n      i += 2\n      return e in CLASS_ESCAPES ? CLASS_ESCAPES[e]! : e.codePointAt(0)!\n    }\n    i += ch.length\n    return ch.codePointAt(0)!\n  }\n  while (i < body.length) {\n    const lo = readCp()\n    if (lo === null) return null\n    if (body[i] === '-' && body[i + 1] !== undefined && body[i + 1] !== ']') {\n      i += 1\n      const hi = readCp()\n      if (hi === null) return null\n      ranges.push([lo, hi])\n    } else {\n      ranges.push([lo, lo])\n    }\n  }\n  return ranges.length ? ranges : null\n}\n\n/** All-literal regex fragment (`\\/\\*`, `\\/\\/`, \u2026) \u2192 its code points, or null on an unescaped metachar. */\nfunction literalCodePoints(frag: string): number[] | null {\n  const out: number[] = []\n  let i = 0\n  while (i < frag.length) {\n    const ch = frag[i]!\n    if (ch === '\\\\') {\n      const e = frag[i + 1]\n      if (e === undefined) return null\n      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e]! : e.codePointAt(0)!)\n      i += 2\n      continue\n    }\n    if (META.has(ch)) return null\n    out.push(ch.codePointAt(0)!)\n    i += 1\n  }\n  return out.length ? out : null\n}\n\n/**\n * Recognize one scannable arm from its regex source, or null if it isn't one of\n * the three structural shapes. Order matters: char-class run, then\n * open-until-terminator, then delimited.\n */\nexport function parseScanShape(source: string): ScanShape | null {\n  // [X]+ / [X]* \u2014 a positive char-class run (a leading `^` negation is not one).\n  let m = /^\\[((?:\\\\.|[^\\]])+)\\]([+*])$/.exec(source)\n  if (m) {\n    if (m[1]!.startsWith('^')) return null\n    const ranges = parseClassRanges(m[1]!)\n    return ranges ? { kind: 'chars', ranges } : null\n  }\n  // <lit>[^X]* \u2014 consume a literal opener, then run until a terminator char.\n  m = /^(.*?)\\[\\^((?:\\\\.|[^\\]])+)\\]\\*$/.exec(source)\n  if (m) {\n    const open = literalCodePoints(m[1]!)\n    const stop = parseClassRanges(m[2]!)\n    if (open && stop) return { kind: 'until', open, stop }\n    return null\n  }\n  // <open>(?:\u2026)*<close> \u2014 delimited token scanned to its first close literal.\n  // Reject escape-aware bodies (a literal `\\\\` in the source \u21D2 string-like), where\n  // \"scan to first close\" would wrongly stop at an escaped delimiter.\n  if (!source.includes('\\\\\\\\')) {\n    m = /^(.*?)\\((?:\\?:)?[\\s\\S]*\\)\\*(.*?)$/.exec(source)\n    if (m && m[1] && m[2]) {\n      const open = literalCodePoints(m[1])\n      const close = literalCodePoints(m[2])\n      if (open && close) return { kind: 'delimited', open, close }\n    }\n  }\n  return null\n}\n\nconst classCond = (cVar: string, ranges: Array<[number, number]>): string =>\n  ranges\n    .map(([lo, hi]) => (lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`))\n    .join(' || ')\n\n/** Literal-match condition at `base + k` for each code point; uses `firstVar` at offset 0. */\nconst litCond = (base: string, cps: number[], firstVar?: string): string =>\n  cps\n    .map((cp, k) =>\n      k === 0 && firstVar\n        ? `${firstVar} === ${cp}`\n        : `input.charCodeAt(${base}${k ? ` + ${k}` : ''}) === ${cp}`,\n    )\n    .join(' && ')\n\n/** `_e` after consuming one token of `shape`, given its opening char is at `c`/`_e`. */\nfunction advanceExpr(shape: ScanShape): { setup: string[]; endVar: string } {\n  if (shape.kind === 'chars') {\n    // Consume the whole run so a labeled chunk spans the full run (the unlabeled\n    // path consumes one char per outer iteration; either is correct for skipping).\n    return {\n      setup: [\n        `      _e++`,\n        `      while (_e < input.length) { const c2 = input.charCodeAt(_e); if (${classCond('c2', shape.ranges)}) _e++; else break }`,\n      ],\n      endVar: '_e',\n    }\n  }\n  if (shape.kind === 'until') {\n    return {\n      setup: [\n        `      let j = _e + ${shape.open.length}`,\n        `      while (j < input.length && !(${classCond('input.charCodeAt(j)', shape.stop)})) j++`,\n      ],\n      endVar: 'j',\n    }\n  }\n  const n = shape.close.length\n  return {\n    setup: [\n      `      let j = _e + ${shape.open.length}`,\n      `      while (j + ${n - 1} < input.length && !(${litCond('j', shape.close)})) j++`,\n    ],\n    endVar: n === 1 ? '(j + 1 <= input.length ? j + 1 : input.length)' : `(j + ${n} <= input.length ? j + ${n} : input.length)`,\n  }\n}\n\n/** The `if (<opens here>) {` guard line for a shape, dispatched on `c`/`_e`. */\nfunction guardLine(shape: ScanShape): string {\n  const cond = shape.kind === 'chars' ? classCond('c', shape.ranges) : litCond('_e', shape.open, 'c')\n  return `    if (${cond}) {`\n}\n\n/**\n * One loop branch for a shape, dispatched on the current char `c` (= charCodeAt(_e)).\n * Each branch advances `_e` past the matched token and `continue`s the scan loop.\n */\nexport function scanBranch(shape: ScanShape): string {\n  if (shape.kind === 'chars') {\n    // Unlabeled: consume one char and re-enter the loop (whole-run span logged once\n    // by the caller's CAP_RECORD). Cheaper than the labeled full-run consume.\n    return `    if (${classCond('c', shape.ranges)}) { _e++; continue }`\n  }\n  const { setup, endVar } = advanceExpr(shape)\n  return [guardLine(shape), ...setup, `      _e = ${endVar}`, `      continue`, `    }`].join('\\n')\n}\n\n/** Push a [start, end, kind] trivia chunk when capturing (`_cap`). */\nfunction captureChunk(startVar: string, kindIndex: number): string[] {\n  return [\n    `      if (_cap) {`,\n    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(${startVar}, _e, ${kindIndex})`,\n    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(${startVar}, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,\n    `      }`,\n  ]\n}\n\n/**\n * A labeled branch: consume the shape's full token and log one [start, end,\n * kindIndex] trivia chunk. Unlike scanBranch this always consumes the whole run\n * (a chunk must span the entire token) and captures inline per-chunk.\n */\nexport function scanBranchLabeled(shape: ScanShape, kindIndex: number): string {\n  const { setup, endVar } = advanceExpr(shape)\n  const lines = [guardLine(shape), `      const _cs = _e`, ...setup]\n  if (endVar !== '_e') lines.push(`      _e = ${endVar}`)\n  lines.push(...captureChunk('_cs', kindIndex), `      continue`, `    }`)\n  return lines.join('\\n')\n}\n", "import type { Combinator } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport { type ScanShape, parseScanShape, scanBranch, scanBranchLabeled } from './scannable-run.ts'\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\nfunction oneOrMoreInner(p: Combinator<unknown>): Combinator<unknown> | null {\n  const d = p._def\n  if (d.tag === 'oneOrMore') return d.parser\n  if (d.tag === 'many' && d.min >= 1) return d.parser\n  return null\n}\n\nfunction choiceArms(p: Combinator<unknown>): Combinator<unknown>[] | null {\n  if (p._def.tag === 'choice') return p._def.parsers\n  return null\n}\n\n/** The scannable shape of one arm (a regex), or null if it isn't scannable. */\nfunction armShape(arm: Combinator<unknown>): ScanShape | null {\n  const src = getCoreRegexDef(arm)?.source\n  return src ? parseScanShape(src) : null\n}\n\n/**\n * A trivia parser that lowers to a hand-rolled char-scan loop: `oneOrMore(choice(\n * \u2026))` (or `many`, min\u22651) where EVERY arm is a scannable shape (a `[X]+` run, a\n * `<lit>[^X]*` open-until-terminator, or a `<open>(?:\u2026)*<close>` delimited token\n * \u2014 see scannable-run.ts). Returns the per-arm shapes, or a single-element list\n * for a bare scannable regex, or null (\u2192 caller falls back to the regex/generic\n * trivia path). A single alternation regex is NOT scannable (one exec matches one\n * arm per call, defeating the loop).\n */\nexport function analyzeTriviaFastPath(trivia: Combinator<unknown>): ScanShape[] | null {\n  const core = unwrapTrivia(trivia)\n\n  const directSrc = getCoreRegexDef(core)?.source\n  if (directSrc) {\n    const shape = parseScanShape(directSrc)\n    return shape && shape.kind === 'chars' ? [shape] : null\n  }\n\n  const inner = oneOrMoreInner(core)\n  if (!inner) return null\n\n  const innerShape = armShape(inner)\n  if (innerShape) return innerShape.kind === 'chars' ? [innerShape] : null\n\n  const arms = choiceArms(inner)\n  if (!arms || arms.length < 2) return null\n\n  const shapes: ScanShape[] = []\n  for (const arm of arms) {\n    const shape = armShape(arm)\n    if (!shape) return null\n    shapes.push(shape)\n  }\n  return shapes\n}\n\nconst CAP_RECORD = [\n  `  if (_cap && _e > _pos) {`,\n  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n  `  }`,\n].join('\\n')\n\n/** One char-scan loop carrying a branch per scannable shape, dispatched on `c`. */\nfunction composeFastLoop(shapes: ScanShape[]): string {\n  return [\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...shapes.map(scanBranch),\n    `    break`,\n    `  }`,\n  ].join('\\n')\n}\n\n/** Emit a specialized `_tfN` that skips (unlabeled) trivia via a char-scan loop. */\nexport function buildFastTriviaFnDecl(fnName: string, shapes: ScanShape[]): string {\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    composeFastLoop(shapes),\n    CAP_RECORD,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/**\n * A LABELED trivia parser whose every arm is scannable \u2192 per-arm shape + kind\n * index, or null. Same recognition as analyzeTriviaFastPath, but keyed by the\n * labeled arm kinds so the fast loop can log each chunk's kind. Generalizes what\n * used to be a hardcoded ws-run + block-comment special case to any scannable\n * shape set / arm count.\n */\nexport function analyzeLabeledScannableRun(\n  trivia: Combinator<unknown>,\n): Array<{ shape: ScanShape; kindIndex: number }> | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  const out: Array<{ shape: ScanShape; kindIndex: number }> = []\n  for (const arm of spec.arms) {\n    const src = getCoreRegexDef(arm.parser)?.source\n    const shape = src ? parseScanShape(src) : null\n    if (!shape) return null\n    out.push({ shape, kindIndex: arm.kindIndex })\n  }\n  return out\n}\n\n/** Emit a labeled scannable trivia `_tfN`: char-scan loop with per-chunk kind capture. */\nexport function buildLabeledScannableTriviaFnDecl(\n  fnName: string,\n  arms: ReadonlyArray<{ shape: ScanShape; kindIndex: number }>,\n): string {\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...arms.map(a => scanBranchLabeled(a.shape, a.kindIndex)),\n    `    break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/** Labeled trivia with regex arms \u2014 per-chunk kind capture in compiled output. */\nexport function buildLabeledRegexTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  reNames: string[],\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const re = reNames[i]!\n    const k = arm.kindIndex\n    return [\n      `    ${re}.lastIndex = _e`,\n      `    const _m${i} = ${re}.exec(input)`,\n      `    if (_m${i} && _m${i}.index === _e) {`,\n      `      const _ce = _e + _m${i}[0].length`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\nexport function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  for (const arm of spec.arms) {\n    if (!getCoreRegexDef(arm.parser)) return null\n  }\n  return spec\n}\n\n/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */\nexport function buildLabeledRuntimeTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  rpStartIndex: number,\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const k = arm.kindIndex\n    const ri = rpStartIndex + i\n    return [\n      `    const _r${i} = _rp[${ri}].parse(input, _e, _ctx)`,\n      `    if (_r${i}.ok && _r${i}.span.end > _e) {`,\n      `      const _ce = _r${i}.span.end`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n", "import type { ParserDef } from '../types.ts'\n\n/** `(c, r, s, tl) => mk('Type', c, r, s, tl)` \u2014 CSS perf regression builder shape. */\nconst MK_BUILD_RE =\n  /^\\(\\s*(?:\\w+\\s*,\\s*){3}\\w+\\s*\\)\\s*=>\\s*mk\\s*\\(\\s*(['\"])([^'\"]+)\\1\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*\\)\\s*$/\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Any callee \u2014 covers `mk`, `import_x.mk`, `__vite_ssr_import_0__.mk`, etc. */\nfunction looseMkBuildRe(type: string): RegExp {\n  return new RegExp(\n    String.raw`^\\(\\s*(?:\\w+\\s*,\\s*){3}\\w+\\s*\\)\\s*=>\\s*.+\\(\\s*(['\"])${escapeRegExp(type)}\\1\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*,\\s*\\w+\\s*\\)\\s*$`,\n  )\n}\n\n/**\n * When a node() build is a thin `mk(type, \u2026)` wrapper, emit the object literal\n * at the call site instead of `_build[n](\u2026)`.\n */\nexport function analyzeMkInlineBuild(def: Extract<ParserDef, { tag: 'node' }>): string | null {\n  const src = (def.buildSrc ?? def.build.toString()).trim()\n  const strict = src.match(MK_BUILD_RE)\n  if (strict) {\n    const mkType = strict[2]!\n    return mkType === def.type ? def.type : null\n  }\n  if (looseMkBuildRe(def.type).test(src)) return def.type\n  return null\n}\n\n/** Object literal matching `stub-build.ts` `mk()` without the function call. */\nexport function emitInlineMkNodeExpr(\n  type: string,\n  chV: string,\n  rawV: string,\n  pos: string,\n  endVar: string,\n  tlV: string,\n): string {\n  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`\n}\n", "/** Builtins allowed in inlined transform bodies (not treated as free closure refs). */\nconst INLINE_BUILTINS = new Set([\n  'parseInt', 'parseFloat', 'String', 'Number', 'Boolean', 'Object', 'Array', 'Math', 'JSON',\n  'undefined', 'null', 'true', 'false', 'NaN', 'Infinity',\n])\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Source text for a transform callback \u2014 macro `fnSrc` or arrow `toString()`. */\nexport function transformFnSource(fn: Function, fnSrc?: string | null): string | null {\n  if (fnSrc) return fnSrc.trim()\n  const s = fn.toString().trim()\n  if (s.includes('[native code]')) return null\n  return s\n}\n\nfunction replaceParam(body: string, param: string, valueVar: string): string {\n  return body.replace(new RegExp(`\\\\b${escapeRegExp(param)}\\\\b`, 'g'), valueVar)\n}\n\nfunction stripForIdCheck(body: string): string {\n  return body\n    .replace(/'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"/g, '\"\"')\n    .replace(/\\bas\\s+const\\b/g, '')\n    .replace(/\\b[A-Za-z_$][\\w$]*\\s*:/g, ':')\n}\n\nfunction hasFreeIdentifiers(body: string, allowed: ReadonlySet<string>): boolean {\n  const stripped = stripForIdCheck(body)\n  const ids = stripped.match(/\\b[A-Za-z_$][\\w$]*\\b/g) ?? []\n  for (const id of ids) {\n    if (INLINE_BUILTINS.has(id)) continue\n    if (allowed.has(id)) continue\n    return true\n  }\n  return false\n}\n\n/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */\nexport function tryInlineUnaryTransform(src: string, valueVar: string): string | null {\n  const allowed = new Set([valueVar])\n  const nullary = src.match(/^\\(\\s*\\)\\s*=>\\s*(.+)$/)\n  if (nullary) {\n    const body = nullary[1]!.trim()\n    return hasFreeIdentifiers(body, allowed) ? null : body\n  }\n  const m = src.match(/^(\\w+)\\s*=>\\s*(.+)$/)\n  if (!m) return null\n  const body = replaceParam(m[2]!.trim(), m[1]!, valueVar)\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n\n/** Parse `[a, , c]` destructuring slots (null = ignore). */\nexport function parseArrayDestructure(pattern: string, arity: number): (string | null)[] {\n  const slots: (string | null)[] = []\n  for (const part of pattern.split(',')) {\n    const name = part.trim()\n    slots.push(name === '' || name === '_' ? null : name)\n  }\n  while (slots.length < arity) slots.push(null)\n  return slots.slice(0, arity)\n}\n\n/**\n * `([x, y]) => body` \u2014 substitute destructure names with sequence value vars.\n * Caller must ensure body only references slotted params (+ builtins).\n */\nexport function tryInlineDestructureTransform(\n  src: string,\n  valueVars: string[],\n): string | null {\n  const m = src.match(/^\\(\\s*\\[([^\\]]*)\\]\\s*\\)\\s*=>\\s*(.+)$/s)\n  if (!m) return null\n  const slots = parseArrayDestructure(m[1]!, valueVars.length)\n  let body = m[2]!.trim()\n  const allowed = new Set(valueVars)\n  for (let i = 0; i < slots.length; i++) {\n    const name = slots[i]\n    if (name) body = replaceParam(body, name, valueVars[i]!)\n  }\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n", "/**\n * Compile a Combinator<T> definition tree into an optimized JavaScript function.\n *\n * Design: every sub-emitter uses early-return on failure. Fallible contexts\n * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a\n * `break <label>` rather than an IIFE return \u2014 no function call, no result\n * object allocation per node.\n */\nimport type { Combinator, ParserDef, FirstSet, ParseResult, ParseContext, ParseError, ChoiceStrategy } from '../types.ts'\nimport { getCoreLiteralValue, getCoreRegexDef } from '../combinators/choice.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport {\n  analyzeLabeledScannableRun,\n  analyzeTriviaFastPath,\n  buildFastTriviaFnDecl,\n  buildLabeledRegexTriviaFnDecl,\n  buildLabeledRuntimeTriviaFnDecl,\n  buildLabeledScannableTriviaFnDecl,\n  labeledTriviaRegexArms,\n} from './trivia-fast-path.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport {\n  transformFnSource,\n  tryInlineUnaryTransform,\n  tryInlineDestructureTransform,\n} from './inline-callback.ts'\n\n// ---------------------------------------------------------------------------\n// Codegen context\n// ---------------------------------------------------------------------------\ntype Ctx = {\n  vars: number\n  indent: number\n  /** Regex declarations hoisted to module scope */\n  regexDecls: string[]\n  /** Dedup map: \"source/flags\" \u2192 variable name (_re0 etc.) */\n  regexMap: Map<string, string>\n  /** Map functions that need to be captured at compile time */\n  mapFns: Array<(v: unknown, span: { start: number; end: number }) => unknown>\n  /**\n   * Source text of each map function, captured in lockstep with `mapFns`\n   * (parallel array). Populated from `def.fnSrc` when present \u2014 lets the macro\n   * inline transform callbacks in codegen-traversal order without a fragile\n   * pre-accumulated positional array. `null` entries mean the source was not\n   * available (interpreter/compile() path with no macro source).\n   */\n  mapFnSrcs: Array<string | null>\n  /** Runtime parser fallbacks (for unknown/_def-less parsers) */\n  runtimeParsers: Array<Combinator<unknown>>\n  /** Whether any case-insensitive lit was emitted (needs collator) */\n  needsCollator: boolean\n  /** Lazy/ref parsers and trivia helpers: parser identity \u2192 generated function name */\n  namedParsers: Map<Combinator<unknown>, string>\n  /** Generated function declaration strings, prepended before the main body */\n  namedFnDecls: string[]\n  /** Active trivia parser (set by grammar() wrappers, cleared on exit) */\n  activeTrivia?: Combinator<unknown> | undefined\n  /** Label table from grammar trivia for default ParseContext. */\n  triviaKindLabels?: readonly string[] | undefined\n  /**\n   * Whether this compile contains any node() rule. When true, terminals emit a\n   * `_ctx._cstLeaves` capture and trivia skips capture trivia tokens \u2014 flowing\n   * through `_ctx` so capture crosses named-function (ref) boundaries correctly.\n   * When false (no node() anywhere) NO capture code is emitted, so non-CST\n   * grammars compile byte-identically to before.\n   */\n  capturing?: boolean\n  /** Inside the trivia-capture fn: terminals emit CSTTrivia tokens, not leaves. */\n  capAsTrivia?: boolean | undefined\n  /** Trivia parser \u2192 name of its capturing variant fn (separate from namedParsers). */\n  triviaCaptureNames: Map<Combinator<unknown>, string>\n  /**\n   * Trivia parser \u2192 name of its fast number-returning variant fn (non-capturing\n   * mode). Returns the new position directly instead of a {ok,value,span} object,\n   * eliminating two object allocations per trivia skip.\n   */\n  triviaFnNames: Map<Combinator<unknown>, string>\n  /** node() build functions captured at compile time (parallel to buildSrcs). */\n  buildFns: Array<(children: ReadonlyArray<unknown>, raw: ReadonlyArray<unknown>, span: { start: number; end: number }, triviaLog: readonly number[], state: unknown) => unknown>\n  /** Source text of each build fn (set from def.buildSrc; null when unavailable). */\n  buildSrcs: Array<string | null>\n  /**\n   * When set, `failStmt` emits `break <label>` instead of `return { ok: false }`.\n   * Used by emitFallible to let labeled blocks act as the failure boundary.\n   */\n  failLabel?: string | undefined\n  /**\n   * Precomputed by analyzeLazyUsage() before codegen starts. emitLazy consults\n   * this to inline a single-use, non-recursive ref directly at its call site\n   * instead of hoisting it into a named function. Undefined when compile()\n   * hasn't run the pre-pass (should not happen in practice \u2014 always set in\n   * compile() \u2014 but kept optional so emitLazy degrades to \"always named\" if\n   * ever invoked without it, e.g. future direct unit tests of emitLazy).\n   */\n  lazyUsage?: {\n    counts: Map<Combinator<unknown>, number>\n    recursive: Set<Combinator<unknown>>\n  }\n}\n\nfunction v(ctx: Ctx, prefix = '_v'): string { return `${prefix}${ctx.vars++}` }\nfunction ind(ctx: Ctx): string { return '  '.repeat(ctx.indent) }\n\n/** Re-indent emitted lines to an absolute depth while preserving relative nesting. */\nfunction reindentStmts(stmts: string[], targetLevels: number): string[] {\n  const nonEmpty = stmts.filter(s => s.trim().length > 0)\n  if (nonEmpty.length === 0) return stmts\n  const minLeading = Math.min(...nonEmpty.map(s => s.length - s.trimStart().length))\n  const targetPrefix = '  '.repeat(targetLevels)\n  return stmts.map(s => (s.trim().length === 0 ? '' : targetPrefix + s.slice(minLeading)))\n}\n\nfunction failReturn(expected: string, posExpr: string): string {\n  return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failReturnArr(expectedArr: string, posExpr: string): string {\n  return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return failReturn(expected, posExpr)\n}\n\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string): string {\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return failReturnArr(expectedArr, posExpr)\n}\n\nfunction emitIfFail(ctx: Ctx, cond: string, body: string): string[] {\n  return [\n    `${ind(ctx)}if (${cond}) {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\nfunction emitElseFail(ctx: Ctx, body: string): string[] {\n  return [\n    `${ind(ctx)}else {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\n/** Sentinel + end-position slot for compiled `rules()` / `withCtx` named fns. */\nconst NAMED_FN_FAIL = '_pfFail'\nconst NAMED_FN_END = '_pfEnd'\n\nfunction namedFnPrelude(): string[] {\n  return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`]\n}\n\nfunction pushNamedFnDecl(\n  ctx: Ctx,\n  fnName: string,\n  bodyStmts: string[],\n  valueVar: string,\n  endVar: string,\n): void {\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx) {`,\n    `  let _pfok = false, _pfv, _pfe = _pos`,\n    `  _pfail: {`,\n    ...reindentStmts(bodyStmts, 2),\n    `    _pfv = ${valueVar}`,\n    `    _pfe = ${endVar}`,\n    `    _pfok = true`,\n    `  }`,\n    `  if (!_pfok) return ${NAMED_FN_FAIL}`,\n    `  ${NAMED_FN_END} = _pfe`,\n    `  return _pfv`,\n    `}`,\n  ].join('\\n'))\n}\n\nfunction emitNamedFnCall(ctx: Ctx, fnName: string, pos: string, failExpected: string): ER {\n  const vv = v(ctx, '_pfv')\n  const ev = v(ctx, '_pfe')\n  return {\n    stmts: [\n      `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, failExpected, pos)),\n      `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n    ],\n    valueVar: vv,\n    endVar: ev,\n  }\n}\n\n/**\n * Emit a spanned-leaf capture into the active node()'s collectors (via _ctx,\n * matching the interpreter). Emitted only in a capturing compile; the runtime\n * `if (_ctx._cstLeaves)` guard means terminals outside a node() pay one\n * predictable branch and nothing else.\n */\nfunction emitLeafCapture(ctx: Ctx, valExpr: string, startExpr: string, endExpr: string): string[] {\n  if (!ctx.capturing) return []\n  if (ctx.capAsTrivia) return []\n  const i = ind(ctx)\n  const lf = v(ctx, '_lf')\n  return [\n    `${i}if (_ctx._cstLeaves) {`,\n    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,\n    `${i}  _ctx._cstLeaves.push(${lf})`,\n    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,\n    `${i}}`,\n  ]\n}\n\nfunction ensureRegexDecl(ctx: Ctx, optimizedSource: string, flags: string): string {\n  const f = 'y' + flags.replace(/[gy]/g, '')\n  const key = `${optimizedSource}/${f}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${optimizedSource}/${f}`)\n    ctx.regexMap.set(key, rName)\n  }\n  return rName\n}\n\n/**\n * When `cap` is truthy, also records `[start, end]` (and optional insertIdx) into\n * `_ctx._triviaLog` / `_ctx._cstTriviaLog`. One emitted function serves both skip\n * and capture call sites \u2014 no duplicate trivia parser tree, no _tc wrapper call.\n */\nfunction ensureTriviaFn(ctx: Ctx): string {\n  const trivia = ctx.activeTrivia!\n  const existing = ctx.triviaFnNames.get(trivia)\n  if (existing) return existing\n  const fnName = `_tf${ctx.triviaFnNames.size}`\n  ctx.triviaFnNames.set(trivia, fnName)\n  ctx.triviaCaptureNames.set(trivia, fnName)\n\n  const labeledSpec = analyzeLabeledTrivia(trivia)\n\n  // UNLABELED trivia: any scannable shape set \u2192 char-scan loop with a single\n  // whole-run [start,end] capture (no per-arm kinds needed).\n  if (!labeledSpec) {\n    const fastShapes = analyzeTriviaFastPath(trivia)\n    if (fastShapes) {\n      ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastShapes))\n      return fnName\n    }\n  } else {\n    // LABELED trivia: if every arm is scannable, the same char-scan loop but with\n    // per-chunk kind capture (generalizes the old hardcoded ws-run + block-comment\n    // case to any shape set / arm count). Otherwise fall to the regex/runtime\n    // kind-tracking loops, which handle non-scannable arms.\n    const labeledShapes = analyzeLabeledScannableRun(trivia)\n    if (labeledShapes) {\n      ctx.namedFnDecls.push(buildLabeledScannableTriviaFnDecl(fnName, labeledShapes))\n      return fnName\n    }\n\n    const regexSpec = labeledTriviaRegexArms(trivia)\n    if (regexSpec) {\n      const reNames: string[] = []\n      for (const arm of regexSpec.arms) {\n        const def = arm.parser._def\n        if (def.tag !== 'regex') break\n        reNames.push(ensureRegexDecl(ctx, def.optimizedSource, def.flags))\n      }\n      if (reNames.length === regexSpec.arms.length) {\n        ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames))\n        return fnName\n      }\n    }\n\n    const rpStart = ctx.runtimeParsers.length\n    for (const arm of labeledSpec.arms) {\n      ctx.runtimeParsers.push(arm.parser)\n    }\n    ctx.namedFnDecls.push(buildLabeledRuntimeTriviaFnDecl(fnName, labeledSpec, rpStart))\n    return fnName\n  }\n\n  const savedIndent    = ctx.indent\n  const savedFailLabel = ctx.failLabel\n  const savedTrivia    = ctx.activeTrivia\n  const savedCapAsTrivia = ctx.capAsTrivia\n  ctx.indent    = 2\n  ctx.failLabel = '_triv'\n  ctx.capAsTrivia = true  // trivia terminals must not push into _cstLeaves\n  ctx.activeTrivia = undefined  // trivia parser must not skip trivia within itself\n  const r = emit(trivia, ctx, '_pos')\n  ctx.indent    = savedIndent\n  ctx.failLabel = savedFailLabel\n  ctx.capAsTrivia = savedCapAsTrivia\n  ctx.activeTrivia = savedTrivia\n\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  _triv: {`,\n    ...reindentStmts(r.stmts, 2),\n    `    _e = ${r.endVar}`,\n    `  }`,\n    `  if (_cap && _e > _pos) {`,\n    `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n    `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n'))\n  return fnName\n}\n\n/** Capturing trivia skip \u2014 same compiled fn as ensureTriviaFn, pass `_cap = 1`. */\nfunction ensureTriviaCaptureFn(ctx: Ctx): string {\n  return ensureTriviaFn(ctx)\n}\n\n// ---------------------------------------------------------------------------\n// The result every emitter returns.\n// After the emitted stmts, `valueVar` holds the parsed value and `endVar`\n// holds the new position. On failure the emitter already emitted an early\n// `return failResult`.\n// ---------------------------------------------------------------------------\ntype ER = { stmts: string[]; valueVar: string; endVar: string }\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\nfunction firstSetCond(codeVar: string, fs: FirstSet): string {\n  if (fs.kind === 'any') return 'true'\n  if (fs.kind === 'empty') return 'false'\n  return fs.ranges.map(r =>\n    r.lo === r.hi\n      ? `${codeVar} === ${r.lo}`\n      : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`\n  ).join(' || ')\n}\n\n// \u2500\u2500 CST/trivia capture rollback: cheap when no buffer is active \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The four capture buffers (`_cstLeaves`, `_cstRawChildren`, `_cstTriviaLog`,\n// `_triviaLog`) are usually all undefined on the hot path (a grammar with any\n// node() compiles with ctx.capturing=true, but at runtime most callers don't\n// request a CST \u2014 they only want the value). Reading `_x?.length ?? 0` four\n// times per fallible block \u2014 and emitFallible runs for every sequence term,\n// repeat item, optional, and choice arm \u2014 turned into a measurable de-opt\n// (compiled CSS regressed ~2.3\u00D7). We gate the whole save/restore on a single\n// boolean: when no buffer is live the marks are 0 and the restore is one test.\n/** Body of a capture restore \u2014 resets each live buffer to its saved length. */\nfunction captureRestoreBody(mL: string, mR: string, mTl: string, mLg: string | null): string {\n  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}`\n  // `_triviaLog` is the standalone diagnostic trivia log. The interpreter only\n  // rewinds it on a failed *choice* arm (choice.ts), NOT on a failed sequence\n  // term \u2014 a sequence returns the failure with earlier trivia still logged. To\n  // stay byte-for-byte at parity with the interpreter, only rewind it where the\n  // interpreter does (choice arms); sequence-term rollbacks (emitFallible) leave\n  // it intact.\n  return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base\n}\n\n/**\n * True when parsing `p` may push a capture (leaf/child/trivia) into the active\n * buffers and THEN fail, leaving partial state that an enclosing node() would\n * wrongly absorb. Used to decide whether a fallible block needs CST-rollback.\n *\n * Sound over-approximation: the ONLY constructs that capture-then-fail are\n *   - a sequence whose non-final term captures before a later term can fail\n *   - a sepBy/oneOrMore item-then-separator partial (handled by their own\n *     dedicated rollback, so still covered conservatively here)\n * Atomic terminals (literal/regex/keywords/charClass/guard/not) fail without\n * having captured. node() buffers into a private sub-scope and discards it on\n * failure, so it never leaks. choice/firstMatch roll back each failed arm\n * internally. optional/many never \"fail\" with partial output. Delegating\n * wrappers (transform/label/grammar/withCtx/expect/skip) pass through to inner.\n */\nfunction mayLeavePartialCapture(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    // Atomic / non-capturing-then-failing: a failure happens before any push.\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'not':\n    case 'trivia':\n    case 'scanTo':\n    case 'unknown':\n      return false\n    // node() captures into its own private buffers and rolls them back on\n    // failure (emitNode restores _ctx.* and never pushes on the !ok path).\n    case 'node':\n      return false\n    // choice/firstMatch already roll back each failed arm; on overall failure\n    // nothing committed remains.\n    case 'choice':\n      return false\n    // optional never fails; many/oneOrMore only \"fail\" with zero captured items.\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n      return false\n    // sepBy emits its own per-iteration rollback in emitSepBy.\n    case 'sepBy':\n      return false\n    // A sequence is the real case: an earlier capturing term followed by a term\n    // that can fail leaves the earlier captures buffered.\n    case 'sequence': {\n      const parts = d.parsers\n      // Only risky if >=2 terms and some non-final term can capture.\n      if (parts.length < 2) return parts.some(x => mayLeavePartialCapture(x, seen))\n      for (let i = 0; i < parts.length - 1; i++) {\n        if (hasNodeDef(parts[i]!) || capturesLeaf(parts[i]!)) return true\n      }\n      return false\n    }\n    // Delegating wrappers: defer to the wrapped parser.\n    case 'transform':\n    case 'label':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'skip':\n      return mayLeavePartialCapture(d.main, seen)\n    case 'recover':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'lazy': {\n      try { return mayLeavePartialCapture(d.thunk(), seen) } catch { return true }\n    }\n    // Unknown shapes: be safe and keep the rollback.\n    default:\n      return true\n  }\n}\n\n/** True when `p` can push a leaf/node into the capture buffers on success. */\nfunction capturesLeaf(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'node':\n      return true\n    case 'not':\n    case 'guard':\n    case 'trivia':\n    case 'unknown':\n      return false\n    case 'sequence':\n    case 'choice':\n      return d.parsers.some(x => capturesLeaf(x, seen))\n    case 'sepBy':\n      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen)\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'label':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n    case 'recover':\n      return capturesLeaf(d.parser, seen)\n    case 'skip':\n      return capturesLeaf(d.main, seen)\n    case 'scanTo':\n      return true\n    case 'lazy': {\n      try { return capturesLeaf(d.thunk(), seen) } catch { return true }\n    }\n    default:\n      return true\n  }\n}\n\n/** Wrap stmts + success return in an IIFE. Returns the IIFE expression string. */\nfunction asIIFE(stmts: string[], valueVar: string, endVar: string, startPos: string, indent: string): string {\n  return [\n    `(() => {`,\n    ...stmts,\n    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,\n    `${indent}})()`,\n  ].join('\\n')\n}\n\n/**\n * Emit `inner` as a labeled block with flat result variables \u2014 no IIFE call,\n * no `{ ok, value, span }` object allocation.  The returned stmts declare:\n *   let ${okVar} = false, ${valVar}, ${endVar} = ${pos}\n *   ${label}: { <inner stmts using break ${label} on failure>; capture success }\n * Callers read ${okVar} to branch on success/failure.\n */\nfunction emitFallible(\n  inner: Combinator<unknown>,\n  ctx: Ctx,\n  pos: string,\n): { stmts: string[]; okVar: string; valVar: string; endVar: string } {\n  const lbl  = v(ctx, '_lbl')\n  const okV  = `${lbl}ok`\n  const valV = `${lbl}v`\n  const endV = `${lbl}e`\n\n  const savedLabel  = ctx.failLabel\n  const savedIndent = ctx.indent\n  ctx.failLabel = lbl\n  ctx.indent    = savedIndent + 1\n  const r = emit(inner, ctx, pos)\n  ctx.failLabel = savedLabel\n  ctx.indent    = savedIndent\n\n  const ind0 = ind(ctx)\n  // In capturing mode, roll back any CST captures made by a FAILED attempt \u2014 a\n  // sub-parser may match terminals (e.g. a sequence that consumes '[') and then\n  // fail on a later term, breaking out with those leaves/trivia still buffered.\n  // Without this they leak into the enclosing node()'s children. (The non-disjoint\n  // choice path does the same per-arm; a disjoint choice commits to one arm and\n  // relies on this boundary to undo a failed commit.)\n  //\n  // The rollback is only needed when `inner` can push a capture and THEN fail\n  // (i.e. leave partial buffered state). Atomic terminals, self-contained nodes,\n  // choices/repeats that roll back internally, etc. never leave partial captures\n  // \u2014 emitting the save/restore around every fallible block (every sequence term)\n  // was a ~2.3\u00D7 compiled-CSS regression. Gate it on the structural predicate so\n  // hot grammars compile back to tight code while correctness is preserved.\n  // A failed sequence term does NOT rewind `_triviaLog` (the interpreter leaves\n  // earlier trivia logged) \u2014 only the CST child buffers are restored here.\n  const needsRollback = ctx.capturing && mayLeavePartialCapture(inner)\n  const mL  = needsRollback ? v(ctx, '_fcl')  : null\n  const mR  = needsRollback ? v(ctx, '_fcr')  : null\n  const mTl = needsRollback ? v(ctx, '_fctl') : null\n  const stmts = [\n    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,\n    ...(mL ? [\n      `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,\n      `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,\n      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,\n    ] : []),\n    `${ind0}${lbl}: {`,\n    ...r.stmts,\n    `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,\n    `${ind0}}`,\n    ...(mL ? [\n      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR!, mTl!, null)} }`,\n    ] : []),\n  ]\n  return { stmts, okVar: okV, valVar: valV, endVar: endV }\n}\n\n\n// ---------------------------------------------------------------------------\n// Per-combinator emitters\n// ---------------------------------------------------------------------------\n\nfunction emitLit(def: Extract<ParserDef, { tag: 'literal' }>, ctx: Ctx, pos: string): ER {\n  const { value, caseInsensitive } = def\n  const len = value.length\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(JSON.stringify(value))\n  const stmts: string[] = []\n\n  if (caseInsensitive) {\n    ctx.needsCollator = true\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,\n      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${vv}_s`,\n    )\n  } else if (len === 0) {\n    stmts.push(`${ind(ctx)}const ${vv} = ''`)\n  } else if (len === 1) {\n    const code = value.codePointAt(0)!\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else if (len <= 4) {\n    const checks = Array.from({ length: len }, (_, i) =>\n      `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) !== ${value.codePointAt(i)!}`\n    ).join(' || ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || ${checks}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else {\n    // startsWith(str, pos) avoids allocating a slice \u2014 it handles the bounds check\n    // internally and compares in-place. No first-char guard needed either.\n    stmts.push(\n      ...emitIfFail(ctx, `!input.startsWith(${JSON.stringify(value)}, ${pos})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  }\n\n  const endVar = len === 0 ? pos : `${pos} + ${len}`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction escapeKeywordRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\nfunction emitKeywords(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER {\n  const alt = def.words.map(escapeKeywordRe).join('|')\n  const boundary = def.boundary ? `(?![${def.boundary}])` : ''\n  const flags = def.caseInsensitive ? 'iuy' : 'uy'\n  const source = `(?:${alt})${boundary}`\n  const key = `${source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, '\"keyword\"', pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitRegex(def: Extract<ParserDef, { tag: 'regex' }>, ctx: Ctx, pos: string): ER {\n  const flags = 'y' + def.flags.replace(/[gy]/g, '')\n  const key = `${def.optimizedSource}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(`/${def.source}/`)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, expectedStr, pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitSeqValues(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER & { valueVars: string[] } {\n  const startV = v(ctx, '_start')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${startV} = ${pos}`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  const valueVars: string[] = []\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i > 0 && ctx.activeTrivia) {\n      if (ctx.capturing) {\n        const capFn = ensureTriviaCaptureFn(ctx)\n        const markV = v(ctx, '_mk')\n        const markTl = v(ctx, '_mktl')\n        const markLog = v(ctx, '_mklg')\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(\n          `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n          `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n        )\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      } else {\n        const trivFn = ensureTriviaFn(ctx)\n        stmts.push(`${ind(ctx)}${curV} = ${trivFn}(input, ${curV}, _ctx)`)\n      }\n    }\n    const r = emit(def.parsers[i]!, ctx, curV)\n    stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`)\n    valueVars.push(r.valueVar)\n  }\n\n  return { stmts, valueVar: valueVars[valueVars.length - 1] ?? 'null', endVar: curV, valueVars }\n}\n\nfunction emitSeq(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos)\n  const arrV = v(ctx, '_arr')\n  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(', ')}]`)\n  return { stmts, valueVar: arrV, endVar }\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = JSON.stringify(\n    def.parsers.map(p => {\n      const d = p._def\n      if (d.tag === 'literal') return JSON.stringify(d.value)\n      if (d.tag === 'regex') return `/${d.source}/`\n      return p._tag\n    })\n  )\n\n  // \u2500\u2500 Disjoint: O(1) first-char dispatch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  if (def.disjoint) {\n    const codeV = v(ctx, '_code')\n    const valV = v(ctx, '_chv')\n    const endV = v(ctx, '_che')\n    const stmts: string[] = [\n      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`,\n    ]\n\n    let first = true\n    for (const p of def.parsers) {\n      const cond = firstSetCond(codeV, p._meta.firstSet)\n      const kw = first ? 'if' : 'else if'\n      first = false\n      stmts.push(`${ind(ctx)}${kw} (${cond}) {`)\n      ctx.indent++\n      const r = emit(p, ctx, pos)\n      stmts.push(...r.stmts)\n      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}`)\n      stmts.push(`${ind(ctx)}${endV} = ${r.endVar}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n    }\n    stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n    return { stmts, valueVar: valV, endVar: endV }\n  }\n\n  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 greedyClassify: run the super-regex once, classify by string equality \u2500\u2500\u2500\u2500\n// Single regex exec + O(n_literals) string comparisons. Zero backtracking.\nfunction emitGreedyClassify(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  superIndex: number,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const superParser = def.parsers[superIndex]!\n  const regexDef = getCoreRegexDef(superParser)!\n\n  // Hoist the regex (same mechanism as emitRegex, with dedup)\n  const cleanFlags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n  const reKey = `${regexDef.source}/${cleanFlags}`\n  let reVar = ctx.regexMap.get(reKey)\n  if (reVar === undefined) {\n    reVar = `_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`)\n    ctx.regexMap.set(reKey, reVar)\n  }\n\n  const matchV = v(ctx, '_gm')\n  const wordV  = v(ctx, '_gw')\n  const endV   = v(ctx, '_ge')\n  const valV   = v(ctx, '_gcv')\n\n  const stmts: string[] = [\n    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,\n    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, allExpected, pos)),\n    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,\n    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,\n    `${ind(ctx)}let ${valV}`,\n  ]\n\n  // For each literal arm: if word === literal, capture + transform chain\n  let first = true\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i === superIndex) continue\n    const p = def.parsers[i]!\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) continue\n\n    const kw = first ? 'if' : 'else if'\n    first = false\n    stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx)\n    stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV))\n    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n\n  // Regex arm: capture + transform chain for the matched word\n  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx)\n  const regexKw = first ? 'if' : 'else'\n  stmts.push(`${ind(ctx)}${regexKw} {`)\n  ctx.indent++\n  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 literalsLongestFirst: sorted startsWith checks, no backtracking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfunction emitLiteralsLongestFirst(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  sortedIndices: number[],\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const valV = v(ctx, '_llv')\n  const endV = v(ctx, '_lle')\n  const stmts: string[] = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`]\n\n  let first = true\n  for (const idx of sortedIndices) {\n    const p = def.parsers[idx]!\n    const litVal = getCoreLiteralValue(p)!\n    const litLen = litVal.length\n\n    // Emit the literal check as a direct condition (no IIFE/try-catch \u2014 literals never throw)\n    const litCond = emitLiteralCondition(litVal, pos)\n    const kw = first ? 'if' : 'else if'\n    first = false\n\n    const litEnd = `${pos} + ${litLen}`\n    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx)\n    stmts.push(\n      ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),\n      ...tR.stmts,\n      `${ind(ctx)}${valV} = ${tR.valueVar}`,\n      `${ind(ctx)}${endV} = ${litEnd}`,\n    )\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n  stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 firstMatch fallback: PEG + auto-not inline rejection + per-arm gates \u2500\u2500\u2500\u2500\u2500\n// Uses labeled blocks (emitFallible) instead of IIFE+try/catch to avoid V8\n// deoptimization from exception-based control flow.\nfunction emitFirstMatch(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const resValV = v(ctx, '_crv')\n  const resEndV = v(ctx, '_cre')\n  const resOkV  = v(ctx, '_crok')\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n  ]\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const p = def.parsers[i]!\n    const gate    = def.gates[i]\n    const autoNot = def.autoNot[i]\n\n    // Gate: register predicate in mapFns; condition guards entire arm attempt\n    let gateCond: string | null = null\n    if (gate) {\n      const gateIdx = ctx.mapFns.length\n      ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n      gateCond = `_mf[${gateIdx}](_ctx.state)`\n    }\n    const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`\n\n    // In capturing mode, save leaf-array lengths before the arm so we can roll\n    // back any leaves pushed by a failed or auto-not-rejected arm. Only needed\n    // when the arm can actually leave partial captures (a capture-then-fail), or\n    // when it captures and an auto-not check can reject an otherwise-successful\n    // match. Atomic/self-contained arms skip the save/restore entirely.\n    const armHasAutoNot = !!(autoNot && autoNot.length > 0)\n    const armNeedsRollback = ctx.capturing &&\n      (mayLeavePartialCapture(p) || (armHasAutoNot && capturesLeaf(p)))\n    const markLeaves = armNeedsRollback ? v(ctx, '_cml') : null\n    const markRaw    = armNeedsRollback ? v(ctx, '_cmr') : null\n    const markTl     = armNeedsRollback ? v(ctx, '_cmtl') : null\n    const markLog    = armNeedsRollback ? v(ctx, '_cmlg') : null\n    const rollback   = markLeaves\n      ? captureRestoreBody(markLeaves, markRaw!, markTl!, markLog!)\n      : ''\n\n    stmts.push(`${ind0}if (${skipCond}) {`)\n\n    ctx.indent++\n    const ind1 = ind(ctx)\n    if (markLeaves) {\n      stmts.push(\n        `${ind1}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,\n        `${ind1}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,\n        `${ind1}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,\n        `${ind1}const ${markLog} = _ctx._triviaLog?.length ?? 0`,\n      )\n    }\n    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n    stmts.push(...armStmts)\n    ctx.indent--\n\n    if (autoNot && autoNot.length > 0) {\n      const anCode = v(ctx, '_anc')\n      const rejectCond = autoNot.map(check =>\n        check.kind === 'firstSet'\n          ? firstSetCond(anCode, check.set)\n          : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`\n      ).join(' || ')\n      stmts.push(`${ind0}  if (${okVar}) {`)\n      stmts.push(`${ind0}    const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`)\n      stmts.push(`${ind0}    if (!(${rejectCond})) {`)\n      stmts.push(`${ind0}      ${resValV} = ${valVar}`)\n      stmts.push(`${ind0}      ${resEndV} = ${endVar}`)\n      stmts.push(`${ind0}      ${resOkV} = true`)\n      stmts.push(`${ind0}    }`)\n      stmts.push(`${ind0}  }`)\n      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`)\n      if (rollback) stmts.push(`${ind0}  else { ${rollback} }`)\n    }\n    stmts.push(`${ind0}}`)\n  }\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, allExpected, pos)))\n  return { stmts, valueVar: resValV, endVar: resEndV }\n}\n\nfunction emitNonDisjoint(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  strategy: ChoiceStrategy,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  if (strategy.tag === 'greedyClassify')\n    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 helpers for emitGreedyClassify / emitLiteralsLongestFirst \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Apply transform chain only \u2014 no parsing, value already known. */\nfunction emitTransformChain(p: Combinator<unknown>, baseValue: string, endV: string, startPos: string, ctx: Ctx): ER {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx)\n    const fnIdx = ctx.mapFns.length\n    ctx.mapFns.push(def.fn)\n    ctx.mapFnSrcs.push(def.fnSrc ?? null)\n    const vv = v(ctx)\n    return {\n      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],\n      valueVar: vv,\n      endVar: endV,\n    }\n  }\n  return { stmts: [], valueVar: baseValue, endVar: endV }\n}\n\n/** Emit a condition that is true iff input matches `litVal` at `pos`. No side effects. */\nfunction emitLiteralCondition(litVal: string, pos: string): string {\n  const len = litVal.length\n  if (len === 0) return 'true'\n  if (len > 4) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`\n  // Short string: charCodeAt checks (same as emitLit)\n  const checks = [`${pos} + ${len} <= input.length`]\n  for (let i = 0; i < len; i++) {\n    const code = litVal.codePointAt(i)!\n    checks.push(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) === ${code}`)\n  }\n  return checks.join(' && ')\n}\n\nfunction emitMany(def: Extract<ParserDef, { tag: 'many' | 'oneOrMore' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n\n  if (def.min === 1) {\n    // Inline first mandatory match with early-return on failure\n    const firstR = emit(def.parser, ctx, curV)\n    stmts.push(...firstR.stmts)\n    stmts.push(\n      `${ind(ctx)}${arrV}.push(${firstR.valueVar})`,\n      `${ind(ctx)}${curV} = ${firstR.endVar}`,\n    )\n  }\n\n  stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n  ctx.indent++\n\n  // Mirror interpreter repeat.ts \u2014 skip trivia before each iteration. In capture\n  // mode the trivia is committed to rawChildren immediately and rolled back\n  // (array truncation) if the following item doesn't materialize.\n  let itemPos = curV\n  let rollback = ''\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const npV = v(ctx, '_np')\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      itemPos = npV\n      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`)\n      itemPos = npV\n    }\n  }\n\n  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos)\n  stmts.push(\n    ...iterStmts,\n    `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`,\n    `${ind(ctx)}${arrV}.push(${iterVal})`,\n    `${ind(ctx)}${curV} = ${iterEnd}`,\n  )\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitOptional(def: Extract<ParserDef, { tag: 'optional' }>, ctx: Ctx, pos: string): ER {\n  const valV = v(ctx, '_opt')\n  const endV = v(ctx, '_opte')\n\n  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0 = ind(ctx)\n  const stmts = [\n    ...lblStmts,\n    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,\n    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`,\n  ]\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitSepBy(_p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'sepBy' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n\n  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } =\n    emitFallible(def.parser, ctx, pos)\n\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    ...firstStmts,\n    `${ind(ctx)}if (${firstOk}) {`,\n  ]\n  ctx.indent++\n  stmts.push(\n    `${ind(ctx)}${arrV}.push(${firstVal})`,\n    `${ind(ctx)}${curV} = ${firstEnd}`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  )\n  ctx.indent++\n\n  // Mirror interpreter sepBy \u2014 separate rollback marks for pre-sep and post-sep trivia.\n  let sepAtPos = curV\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const markLv = v(ctx, '_mklv')\n      const spV = v(ctx, '_sp')\n      // Marks taken BEFORE the separator. If either the separator OR the following\n      // item fails, the whole iteration unwinds to here \u2014 crucially undoing the\n      // separator's own captured leaves (markLv) when the item after it fails.\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      sepAtPos = spV\n      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV)\n      stmts.push(\n        ...nextStmts,\n        // item failed \u2192 unwind the separator too, back to the end of the last item\n        `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`,\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const spV = v(ctx, '_sp')\n      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`)\n      sepAtPos = spV\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV)\n      stmts.push(\n        ...nextStmts,\n        `${ind(ctx)}if (!${nextOk}) break`,\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    }\n  } else {\n    // No trivia. Still mark the leaf buffers before the separator so that an item\n    // failing after the separator unwinds the separator's captured leaves too.\n    const markLv = ctx.capturing ? v(ctx, '_mklv') : null\n    const markRw = ctx.capturing ? v(ctx, '_mkrw') : null\n    if (markLv) {\n      stmts.push(\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n      )\n    }\n    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos)\n    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n    const nextRb = markLv\n      ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; `\n      : ''\n    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n      emitFallible(def.parser, ctx, sepEnd)\n    stmts.push(\n      ...nextStmts,\n      `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`,\n      `${ind(ctx)}${arrV}.push(${nextVal})`,\n      `${ind(ctx)}${curV} = ${nextEnd}`,\n    )\n  }\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitScanTo(\n  def: Extract<ParserDef, { tag: 'scanTo' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const curV   = v(ctx, '_stcur')\n  const foundV = v(ctx, '_stfnd')\n  const stmts: string[] = [\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    `${ind(ctx)}let ${foundV} = false`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  ]\n  ctx.indent++\n\n  // Sentinel check and skippers must not emit CST leaves \u2014 they are pure position\n  // probes. Use a non-capturing ctx so their literal()/regex() don't push leaves.\n  const probeCtx: Ctx = { ...ctx, capturing: false }\n\n  // Sentinel check \u2014 labeled block, no IIFE\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV)\n  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`)\n\n  // Skippers \u2014 labeled block per skipper; a failure just means \"not this one\"\n  if (def.skip.length > 0) {\n    const advV = v(ctx, '_stadv')\n    stmts.push(`${ind(ctx)}let ${advV} = false`)\n    for (const skipper of def.skip) {\n      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV)\n      stmts.push(\n        `${ind(ctx)}if (!${advV}) {`,\n        ...skStmts,\n        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,\n        `${ind(ctx)}}`,\n      )\n    }\n    stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`)\n  } else {\n    stmts.push(`${ind(ctx)}${curV}++`)\n  }\n\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  // Fail if sentinel was never found (unless orEOF)\n  if (!def.orEOF) {\n    const sentDef = def.sentinel._def\n    const expectedStr = sentDef.tag === 'literal'\n      ? JSON.stringify([JSON.stringify(sentDef.value)])\n      : `[\"sentinel\"]`\n    stmts.push(...emitIfFail(ctx, `!${foundV}`, failArrBody(ctx, expectedStr, pos)))\n  }\n\n  const valV = v(ctx)\n  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`)\n  // scanTo records its scanned span as one leaf (matching the interpreter), but\n  // only when it actually consumed something.\n  if (ctx.capturing) {\n    const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1)\n    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`)\n  }\n  return { stmts, valueVar: valV, endVar: curV }\n}\n\n/**\n * Negative lookahead. Run the inner parser in a labeled block; if it succeeds,\n * fail; if it fails, succeed consuming nothing (value null, end === pos).\n */\nfunction emitNot(def: Extract<ParserDef, { tag: 'not' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, okVar } = emitFallible(def.parser, ctx, pos)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, '\"not\"', pos)),\n    ],\n    valueVar: 'null',\n    endVar: pos,\n  }\n}\n\n/**\n * CST node rule. Collects the inner parse's terminals/trivia into fresh local\n * arrays (capture is emitted inline by the terminals while capChildren is set),\n * calls the build fn, then records the node in the enclosing node()'s collectors.\n */\nfunction emitNode(def: Extract<ParserDef, { tag: 'node' }>, ctx: Ctx, pos: string): ER {\n  const mkType = analyzeMkInlineBuild(def)\n  let buildIdx: number | null = null\n  if (!mkType) {\n    buildIdx = ctx.buildFns.length\n    ctx.buildFns.push(def.build)\n    ctx.buildSrcs.push(def.buildSrc ?? null)\n  }\n  const i = ind(ctx)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const tlV = v(ctx, '_tl')\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  const stmts: string[] = [\n    `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`,\n    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,\n    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${tlV}`,\n  ]\n  const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos)\n  stmts.push(...innerStmts)\n  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`)\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, failBody(ctx, '\"node\"', pos)))\n\n  const stV = v(ctx, '_nst')\n  stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  const ndV = v(ctx, '_nd')\n  const ndExpr = mkType\n    ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV)\n    : `_build[${buildIdx!}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`\n  stmts.push(\n    `${i}const ${ndV} = ${ndExpr}`,\n    `${i}if (${sc}) ${sc}.push(${ndV})`,\n    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`,\n  )\n\n  return { stmts, valueVar: ndV, endVar }\n}\n\nfunction emitRuntimeFallback(parser: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const idx = ctx.runtimeParsers.length\n  ctx.runtimeParsers.push(parser)\n  const rv = v(ctx, '_rt')\n  const vv = v(ctx, '_rtv')\n  const ev = v(ctx, '_rte')\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failBody(ctx, '\"runtime\"', pos)),\n    `${ind(ctx)}const ${vv} = ${rv}.value`,\n    `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n  ]\n  return { stmts, valueVar: vv, endVar: ev }\n}\n\n/**\n * Compile a lazy/ref parser into a named function declaration.\n *\n * The named function is registered in ctx.namedParsers BEFORE its body is\n * emitted. This breaks the recursion cycle: when the body emitter encounters\n * the same ref again it finds it already registered and emits a call instead\n * of recursing infinitely.\n *\n * All named functions share the parent function's scope (via closure), so they\n * can read _rp, _mf, and all hoisted regex consts without extra args.\n *\n * JavaScript hoists function declarations within a function body, so the order\n * we push to namedFnDecls doesn't affect correctness.\n */\nfunction emitLazy(p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'lazy' }>, ctx: Ctx, pos: string): ER {\n  // Single-use, non-recursive ref: inline its body at this call site instead\n  // of hoisting a named function nobody else calls. Uses the CURRENT ctx\n  // indent/failLabel (unlike the named-function path below, which resets\n  // both for a fresh function scope) \u2014 the resolved combinator is emitted\n  // exactly as if the grammar author had written it inline directly.\n  const usage = ctx.lazyUsage\n  if (usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n    return emit(resolved, ctx, pos)\n  }\n\n  if (!ctx.namedParsers.has(p)) {\n    const fnName = `_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST so recursive refs see it\n\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      // ref.define() not called yet \u2014 fall back to runtime\n      ctx.namedParsers.delete(p)\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in fn body)\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n  }\n\n  const fnName = ctx.namedParsers.get(p)!\n  return emitNamedFnCall(ctx, fnName, pos, '\"parser\"')\n}\n\n// \u2500\u2500 recover: try inner; on failure scan to sentinel, emit ParseError node \u2500\u2500\u2500\u2500\nfunction emitRecover(def: Extract<ParserDef, { tag: 'recover' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0  = ind(ctx)\n  const scanV = v(ctx, '_sc')\n  const errV  = v(ctx, '_err')\n\n  // Sentinel check runs inside the while loop.\n  const whileBodyLevels = ctx.indent + 2\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV)\n\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  let ${scanV} = ${pos}`,\n    `${ind0}  while (${scanV} < input.length) {`,\n    ...reindentStmts(sentStmts, whileBodyLevels),\n    `${ind0}    if (${sentOk}) break`,\n    `${ind0}    ${scanV}++`,\n    `${ind0}  }`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: [] }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${scanV}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// \u2500\u2500 expect: try inner; on failure record a ParseError + recover in place \u2500\u2500\u2500\u2500\u2500\nfunction emitExpect(def: Extract<ParserDef, { tag: 'expect' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n  const ind0 = ind(ctx)\n  const errV = v(ctx, '_err')\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${pos} }, expected: ${JSON.stringify(def.expected)} }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${pos}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// ---------------------------------------------------------------------------\n// Main dispatch\n// ---------------------------------------------------------------------------\nfunction emit(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':   return emitLit(def, ctx, pos)\n    case 'regex':     return emitRegex(def, ctx, pos)\n    case 'keywords':  return emitKeywords(def, ctx, pos)\n    case 'sequence':  return emitSeq(def, ctx, pos)\n    case 'choice':    return emitChoice(def, ctx, pos)\n    case 'many':\n    case 'oneOrMore': return emitMany(def, ctx, pos)\n    case 'optional':  return emitOptional(def, ctx, pos)\n    case 'sepBy':     return emitSepBy(p, def, ctx, pos)\n    case 'transform': {\n      const fnSrc = transformFnSource(def.fn, def.fnSrc)\n      if (fnSrc && def.parser._def.tag === 'sequence') {\n        const seqR = emitSeqValues(def.parser._def, ctx, pos)\n        const inlined = tryInlineDestructureTransform(fnSrc, seqR.valueVars)\n        if (inlined) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...seqR.stmts, `${ind(ctx)}const ${mv} = ${inlined}`],\n            valueVar: mv,\n            endVar: seqR.endVar,\n          }\n        }\n      }\n      const inner = emit(def.parser, ctx, pos)\n      if (fnSrc) {\n        const unary = tryInlineUnaryTransform(fnSrc, inner.valueVar)\n        if (unary) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...inner.stmts, `${ind(ctx)}const ${mv} = ${unary}`],\n            valueVar: mv,\n            endVar: inner.endVar,\n          }\n        }\n      }\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.fn)\n      ctx.mapFnSrcs.push(def.fnSrc ?? null)\n      const mv = v(ctx, '_mapped')\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}const ${mv} = _mf[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`,\n        ],\n        valueVar: mv,\n        endVar: inner.endVar,\n      }\n    }\n    case 'skip': {\n      const mainR = emit(def.main, ctx, pos)\n      const skipR = emit(def.skipped, ctx, mainR.endVar)\n      // skipped is optional \u2014 if it fails we just keep main's end\n      const endV = v(ctx, '_skipe')\n      return {\n        stmts: [\n          ...mainR.stmts,\n          // try skipped; if fails, keep main end\n          `${ind(ctx)}let ${endV} = ${mainR.endVar}`,\n          `${ind(ctx)}try {`,\n          ...reindentStmts(skipR.stmts, ctx.indent + 1),\n          `${ind(ctx)}  ${endV} = ${skipR.endVar}`,\n          `${ind(ctx)}} catch {}`,\n        ],\n        valueVar: mainR.valueVar,\n        endVar: endV,\n      }\n    }\n    case 'lazy':     return emitLazy(p, def, ctx, pos)\n    case 'trivia':   return emit(def.parser, ctx, pos)\n    case 'label':    return emit(def.parser, ctx, pos)\n    case 'grammar': {\n      const savedTrivia = ctx.activeTrivia\n      const savedKindLabels = ctx.triviaKindLabels\n      if (def.clearTrivia) {\n        // noTrivia / parser({ trivia: null }): contiguous terms, no trivia skipped.\n        ctx.activeTrivia = undefined\n        ctx.triviaKindLabels = undefined\n      } else if (def.triviaParser) {\n        ctx.activeTrivia = def.triviaParser\n        if (def.triviaParser._meta.triviaKindLabels) {\n          ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels\n        }\n      }\n      const r = emit(def.parser, ctx, pos)\n      ctx.activeTrivia = savedTrivia\n      ctx.triviaKindLabels = savedKindLabels\n      return r\n    }\n    case 'not':     return emitNot(def, ctx, pos)\n    case 'node':    return emitNode(def, ctx, pos)\n    case 'scanTo':  return emitScanTo(def, ctx, pos)\n    case 'recover': return emitRecover(def, ctx, pos)\n    case 'expect':  return emitExpect(def, ctx, pos)\n    case 'guard': {\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.predicate as (v: unknown, span: unknown) => unknown)\n      const vv = v(ctx)\n      return {\n        stmts: [\n          ...emitIfFail(ctx, `!_mf[${fnIdx}](_ctx.state)`, failBody(ctx, '\"gate\"', pos)),\n          `${ind(ctx)}const ${vv} = null`,\n        ],\n        valueVar: vv,\n        endVar: pos,\n      }\n    }\n    case 'withCtx': {\n      // Store getter for extra value \u2014 _mf[N]() returns the captured value.\n      const evIdx = ctx.mapFns.length\n      const extra = def.extra\n      ctx.mapFns.push((() => extra) as (v: unknown, span: unknown) => unknown)\n\n      // Wrap inner parser as a named function so it receives _ctx as a parameter.\n      // That lets us call it with a modified ctx (user changed) without polluting\n      // the outer _ctx variable for subsequent emits.\n      const innerParser = def.parser as Combinator<unknown>\n      if (!ctx.namedParsers.has(innerParser)) {\n        const fnName = `_wcf${ctx.namedParsers.size}`\n        ctx.namedParsers.set(innerParser, fnName)\n        const savedIndent    = ctx.indent\n        const savedFailLabel = ctx.failLabel\n        ctx.indent    = 1\n        ctx.failLabel = '_pfail'  // failures break _pfail (same as emitLazy)\n        const innerR = emit(innerParser, ctx, '_pos')\n        ctx.indent    = savedIndent\n        ctx.failLabel = savedFailLabel\n        pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar)\n      }\n      const fn = ctx.namedParsers.get(innerParser)!\n\n      const rv = v(ctx, '_wcr')\n      const vv = v(ctx, '_wcv')\n      const ev = v(ctx, '_wce')\n      return {\n        stmts: [\n          `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,\n          `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, '\"withCtx\"', pos)),\n          `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n        ],\n        valueVar: vv,\n        endVar: ev,\n      }\n    }\n    default:         return emitRuntimeFallback(p, ctx, pos)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\nexport type CompiledParser<T> = {\n  parse(input: string, pos?: number): ParseResult<T>\n  /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */\n  parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>\n  /**\n   * Like parse(), but activates error recovery. recover() nodes collect their\n   * ParseErrors into result.errors instead of (only) embedding them as values.\n   * Always returns ParseOk \u2014 top-level failures are still ParseFail.\n   */\n  parseWithErrors(input: string, pos?: number): ParseResult<T> & { errors: ParseError[] }\n  /** The generated source (for inspection / future source maps) */\n  source: string\n  /**\n   * A self-contained JS expression (IIFE) that evaluates to a parse function.\n   * Safe to inline directly into transformed source \u2014 no external references\n   * except for runtime-fallback parsers embedded via closures.\n   * Returns null if the parser cannot be fully inlined (e.g. contains user\n   * closures that can't be serialized).\n   */\n  inlineExpression: string | null\n}\n\n/**\n * Does this combinator tree contain a node() anywhere (following ref/lazy\n * thunks)? Determines whether the compile emits CST capture \u2014 so non-node\n * grammars stay byte-identical. `seen` guards against recursion cycles.\n */\nfunction hasNodeDef(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'node':      return true\n    case 'lazy':      { try { return hasNodeDef(d.thunk(), seen) } catch { return false } }\n    case 'grammar':\n    case 'trivia':\n    case 'label':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'not':\n    case 'transform': return hasNodeDef(d.parser, seen)\n    case 'skip':      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen)\n    case 'sequence':\n    case 'choice':    return d.parsers.some(x => hasNodeDef(x, seen))\n    case 'sepBy':     return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen)\n    case 'scanTo':    return hasNodeDef(d.sentinel, seen) || d.skip.some(x => hasNodeDef(x, seen))\n    case 'recover':   return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen)\n    case 'expect':    return hasNodeDef(d.parser, seen)\n    case 'withCtx':   return hasNodeDef(d.parser, seen)\n    default:          return false\n  }\n}\n\n/** Immediate child combinators of a def, for generic tree walks (childrenOf). */\nfunction childrenOf(def: ParserDef): Combinator<unknown>[] {\n  switch (def.tag) {\n    case 'sequence':\n    case 'choice':    return def.parsers\n    case 'many':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'label':\n    case 'grammar':\n    case 'not':\n    case 'node':\n    case 'withCtx':\n    case 'expect':    return [def.parser]\n    // emitMany's oneOrMore branch and emitSepBy both codegen `def.parser` TWICE\n    // (a mandatory first match, then again inside the repeat loop) \u2014 two real\n    // emit() call sites, so the usage analysis must see two edges here or it\n    // undercounts a single-use `parser` ref as inline-safe when it's actually\n    // referenced from two positions within this one compiled function.\n    case 'oneOrMore': return [def.parser, def.parser]\n    case 'sepBy':     return [def.parser, def.parser, def.separator]\n    case 'skip':      return [def.main, def.skipped]\n    case 'recover':   return [def.parser, def.sentinel]\n    case 'scanTo':    return [def.sentinel, ...def.skip]\n    case 'lazy':\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'unknown':   return []\n  }\n}\n\n/**\n * Static-occurrence analysis for `lazy` (ref()) combinators, ahead of codegen.\n * `emitLazy` currently hoists EVERY lazy ref into its own named function\n * (_pfN), even when it's referenced from exactly one place \u2014 necessary for\n * genuinely recursive/shared rules, wasteful for the common case of a `g.foo`\n * helper rule used for grammar readability but only ever called once. On a\n * large mutually-referential grammar (many `g.xxx` helper rules, each used\n * from ~1 call site) this multiplies function count far past the number of\n * rules a grammar author actually wrote \u2014 observed on the Less grammar:\n * ~1700 compiled functions from ~150 source rules, vs a roughly 1:3 ratio on\n * a comparably-sized but flatter grammar.\n *\n * Returns, for every reachable `lazy` combinator: how many static call sites\n * reference it (`counts`), and whether it participates in a reference cycle\n * (`recursive` \u2014 must stay a named function; inlining a cycle would recurse\n * forever). A ref with count <= 1 and no cycle membership is safe to inline\n * directly at its single call site instead of becoming a named function.\n *\n * Traversal cost: each `lazy` ref's body is descended into at most once\n * (subsequent occurrences just bump the counter) \u2014 polynomial in the number\n * of distinct reachable combinators, matching emitLazy's own memoized\n * codegen cost. Non-lazy nodes are walked without memoization, same as\n * `emit()` itself (a directly-shared non-ref subtree \u2014 discouraged by the\n * `g.xxx` convention but not disallowed \u2014 is revisited per occurrence, same\n * cost class as compilation already pays for it today).\n */\nfunction analyzeLazyUsage(root: Combinator<unknown>): {\n  counts: Map<Combinator<unknown>, number>\n  recursive: Set<Combinator<unknown>>\n} {\n  return analyzeLazyUsageMulti([root])\n}\n\n/**\n * Multi-root variant, for compileRuleMap(): a `rules()` factory's returned\n * map has many top-level entries that legitimately share reachable sub-rules\n * (e.g. `Stylesheet` and `Declaration` both reach `g.valueList`). Walking each\n * entry as its own root into ONE shared counts/descended/active state means a\n * ref's count correctly reflects total usage across the WHOLE rule map \u2014 used\n * once as its own top-level entry AND referenced once internally elsewhere is\n * count 2 (stays a named function, shared correctly), not two independent 1s\n * from two unrelated single-root analyses.\n */\nfunction analyzeLazyUsageMulti(roots: Iterable<Combinator<unknown>>): {\n  counts: Map<Combinator<unknown>, number>\n  recursive: Set<Combinator<unknown>>\n} {\n  const counts = new Map<Combinator<unknown>, number>()\n  const recursive = new Set<Combinator<unknown>>()\n  const descended = new Set<Combinator<unknown>>()\n  const active = new Set<Combinator<unknown>>()\n\n  function walk(p: Combinator<unknown>): void {\n    const def = p._def\n    if (def.tag === 'lazy') {\n      counts.set(p, (counts.get(p) ?? 0) + 1)\n      if (active.has(p)) {\n        recursive.add(p)\n        return\n      }\n      if (descended.has(p)) return\n      descended.add(p)\n      let resolved: Combinator<unknown>\n      try {\n        resolved = def.thunk()\n      } catch {\n        return // ref.define() not called yet \u2014 emitLazy's own try/catch handles this at codegen time\n      }\n      active.add(p)\n      walk(resolved)\n      active.delete(p)\n      return\n    }\n    for (const child of childrenOf(def)) walk(child)\n  }\n\n  for (const root of roots) walk(root)\n  return { counts, recursive }\n}\n\n/**\n * Compile a combinator tree into an optimized parse function at runtime.\n *\n * Uses `new Function` internally, so it will fail in environments with a strict\n * Content Security Policy that omits `'unsafe-eval'`. Prefer the interpreter or\n * macro build plugin in those cases.\n *\n * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide\n */\nexport function compile<T>(combinator: Combinator<T>, mapFnSources?: string[]): CompiledParser<T> {\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    needsCollator: false,\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: hasNodeDef(combinator as Combinator<unknown>),\n    lazyUsage: analyzeLazyUsage(combinator as Combinator<unknown>),\n  }\n\n  const r = emit(combinator as Combinator<unknown>, ctx, '_pos')\n\n  const collatorDecl = ctx.needsCollator\n    ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })\\n`\n    : ''\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ''] : []\n\n  const source = [\n    ...ctx.regexDecls,\n    '',\n    ...namedPrelude,\n    ctx.namedFnDecls.join('\\n\\n'),\n    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  const fn = new Function('input', '_pos', '_rp', '_mf', '_build', '_ctx', [\n    ...ctx.regexDecls,\n    collatorDecl,\n    ...namedPrelude,\n    ...ctx.namedFnDecls.flatMap((decl, i) => (i > 0 ? ['', decl] : [decl])),\n    `let pos = _pos`,\n    ...r.stmts,\n    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ].join('\\n')) as (\n    input: string,\n    pos: number,\n    rp: Array<Combinator<unknown>>,\n    mf: Array<(v: unknown, span: { start: number; end: number }) => unknown>,\n    build: Ctx['buildFns'],\n    ctx: ParseContext,\n  ) => ParseResult<T>\n\n  const defaultCtx: ParseContext = {\n    trackLines: false,\n    ...(ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}),\n  }\n\n  // Prefer per-def sources captured in codegen-traversal order (set by the\n  // macro via def.fnSrc). Fall back to a caller-provided positional array.\n  // The derived array is only usable when every traversed transform carried a\n  // source \u2014 otherwise we can't inline the closures.\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const effectiveSources = mapFnSources ?? derivedSrcs\n\n  // node() build fns inline the same way: every traversed node must carry its\n  // build source (set by the macro via def.buildSrc) or we can't inline.\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n\n  // Build an inline expression when there are no runtime fallbacks, and either\n  // no map-function closures or their source text has been provided for injection.\n  const mfCovered = ctx.mapFns.length === 0 || (effectiveSources !== undefined && effectiveSources.length === ctx.mapFns.length)\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  const inlineExpression: string | null = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null\n\n  return {\n    source,\n    inlineExpression,\n    parse(input: string, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx)\n    },\n    parseWithContext(input: string, parseCtx: ParseContext, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx)\n    },\n    // Note: collects recover()/expect() errors via _errors. Unlike interpreter\n    // parse({recover:true}) it does NOT populate furthestFail \u2014 the compiled path\n    // inlines failures for throughput and deliberately skips _probe bookkeeping.\n    // Callers wanting a furthest-position diagnostic detect unconsumed input\n    // (span.end < input.length) instead, which is mode-agnostic.\n    parseWithErrors(input: string, pos = 0): ParseResult<T> & { errors: ParseError[] } {\n      const errors: ParseError[] = []\n      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors })\n      return { ...result, errors } as ParseResult<T> & { errors: ParseError[] }\n    },\n  }\n}\n\n/**\n * Compile every entry of a `rules(factory)` map's returned object using ONE\n * shared codegen Ctx (regexes, named functions, map/build-fn arrays) instead\n * of running `compile()` independently per entry.\n *\n * Why this exists: `compile()` per entry gives each entry its own namedParsers\n * cache, so a sub-rule reachable from N different top-level entries (e.g.\n * `valueList` reachable from `Declaration`, `CustomDeclaration`, `Guard`, \u2026)\n * gets fully re-compiled N times \u2014 on a richly cross-referential grammar\n * (Less: ~125 rule-map entries, deep mutual reference) this multiplies total\n * compiled size far past what the source grammar actually needs, independent\n * of the per-ref single-use inlining `analyzeLazyUsage` already handles\n * within one compile() call. Sharing one Ctx here means a sub-rule compiles\n * exactly once for the WHOLE rule map, however many entries reach it.\n *\n * Returns a single `replacement` \u2014 ONE shared IIFE, evaluated once, whose\n * result is the `{ key: fn, ... }` map \u2014 meant to replace the entire\n * `rules(factory)` call-expression (not one expression per key; splicing a\n * separate self-contained expression per key would either re-run the shared\n * prelude once per entry or duplicate its text per entry, undoing the win).\n * `keys` lists every entry compileRuleMap() saw, for the caller to validate\n * against the source's own key list.\n *\n * Returns null (same all-or-nothing contract the per-entry `compile()` +\n * `inlineExpression === null` check gave the plugin before) when the map\n * contains anything that can't be inlined \u2014 a runtime-fallback parser, or an\n * uncaptured transform/build closure source. The plugin's existing \"warn and\n * leave this rules() call interpreted\" fallback covers this case unchanged.\n */\nexport function compileRuleMap(\n  ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n): { keys: string[]; replacement: string } | null {\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    needsCollator: false,\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),\n    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),\n  }\n\n  const perEntry = ruleMap.map(([key, rule]) => ({ key, r: emit(rule, ctx, '_pos') }))\n\n  const collatorDecl = ctx.needsCollator\n    ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })\\n`\n    : ''\n\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n  const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== undefined\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  if (!canInline) return null\n\n  const mfDecl = derivedSrcs?.length ? `  const _mf = [${derivedSrcs.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(', ')}]` : ''\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    collatorDecl ? `  ${collatorDecl.trim()}` : '',\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n\n  const entryFnText = (r: ER): string => [\n    `function(input, _pos, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  // One shared IIFE, evaluated ONCE, returning the whole `{ key: fn, ... }`\n  // map \u2014 this whole string is the caller's replacement for the entire\n  // `rules(factory)` call-expression (NOT one expression per key spliced into\n  // a separately-built object literal, which would either re-run the shared\n  // prelude per entry or duplicate its text per entry \u2014 both defeat the point).\n  const objBody = perEntry\n    .map(({ key, r }) => `    ${JSON.stringify(key)}: ${entryFnText(r).split('\\n').join('\\n    ')}`)\n    .join(',\\n')\n  const replacement = [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return {`,\n    objBody,\n    `  }`,\n    `})()`,\n  ].join('\\n')\n\n  return { keys: perEntry.map(e => e.key), replacement }\n}\n\nfunction buildInlineExpression(\n  ctx: Ctx,\n  r: ER,\n  collatorDecl: string,\n  mapFnSources?: string[],\n  buildSources?: string[],\n): string {\n  const bodyLines = [\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ]\n\n  const innerFn = [\n    `function(input, _pos, _ctx) {`,\n    ...bodyLines,\n    `}`,\n  ].join('\\n')\n\n  // Declare _mf / _build inline so the emitted _mf[i] / _build[i] references\n  // resolve without runtime closure arrays.\n  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(', ')}]` : ''\n\n  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    collatorDecl ? `  ${collatorDecl.trim()}` : '',\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n  return [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return ${innerFn}`,\n    `})()`,\n  ].join('\\n')\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Zero-width assertion: succeeds (consuming nothing) only when `predicate`\n * returns true for `ctx.state`. Fails otherwise.\n *\n * Intended for use inside sequence() to gate subsequent parsing on runtime\n * context set with withCtx().\n *\n *   const returnStmt = sequence(\n *     guard(ctx => (ctx as { inFn: boolean }).inFn),\n *     literal('return'), optional(expr)\n *   )\n */\nexport function guard(predicate: (state: unknown) => boolean): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'guard',\n    _meta: meta,\n    _def: { tag: 'guard', predicate },\n    parse(_input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      if (predicate(ctx.state))\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      return { ok: false, expected: ['guard'], span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Runs `combinator` with `ctx.state` set to `extra` for the duration of the parse.\n * The outer user context is restored on exit (lexical scoping).\n *\n *   const functionBody = withCtx({ inFn: true },\n *     sequence(literal('{'), many(statement), literal('}'))\n *   )\n *\n * Read back with guard() or from within a transform's span argument.\n */\nexport function withCtx<U, T>(extra: U, combinator: Combinator<T>): Combinator<T> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'withCtx',\n    _meta: meta,\n    _def: { tag: 'withCtx', extra, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      return combinator.parse(input, pos, { ...ctx, state: extra })\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\n\nexport type { ParseError }\n\n/**\n * Error-recovery combinator. Tries `combinator`; on success returns normally.\n * On failure, scans forward one character at a time until `sentinel` matches\n * (or EOF), then returns a ParseError node spanning the skipped range.\n * The sentinel is NOT consumed \u2014 the caller's grammar continues from there.\n *\n * Intended for IDE/incremental parsers that must produce a result even on\n * broken input. The error path is not optimized; use only where recovery\n * is genuinely needed, not on hot paths.\n *\n *   const stmt = choice(\n *     ifStmt, whileStmt,\n *     recover(exprStmt, literal(';'))\n *   )\n */\nexport function recover<T>(\n  combinator: Combinator<T>,\n  sentinel: Combinator<unknown>,\n): Combinator<T | ParseError> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'recover',\n    _meta: meta,\n    _def: { tag: 'recover', parser: combinator as Combinator<unknown>, sentinel },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n\n      let scanPos = pos\n      while (scanPos < input.length) {\n        if (sentinel.parse(input, scanPos, ctx).ok) break\n        scanPos++\n      }\n\n      const error: ParseError = {\n        _tag: 'parseError',\n        span: { start: pos, end: scanPos },\n        expected: result.expected,\n      }\n      ctx._errors?.push(error)\n      return { ok: true, value: error, span: { start: pos, end: scanPos } }\n    },\n  }\n}\n\nexport function isParseError(value: unknown): value is ParseError {\n  return typeof value === 'object' && value !== null && (value as ParseError)._tag === 'parseError'\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\n\nexport type { ParseError }\n\n/**\n * Statically derive the \"expected\" token set from a combinator's structure,\n * so a failure can name what it wanted without running anything:\n *\n *   literal('}')        -> ['\"}\"']\n *   keywords(['a','b']) -> ['\"a\"', '\"b\"']\n *   choice(x, y)        -> expected(x) ++ expected(y)   (all alternatives)\n *   sequence(a, b, \u2026)   -> expected(a)                  (only the first term can fail first)\n *   label('s', x)       -> ['s']                        (an explicit name wins)\n *\n * This is what lets expect() report a meaningful, IDENTICAL expectation in both\n * the interpreter and the compiled output (the compiled path does not rebuild the\n * runtime `expected` array, so it reads this precomputed set instead).\n */\nexport function staticExpected(c: Combinator<unknown>): string[] {\n  const def = c._def\n  switch (def.tag) {\n    case 'literal':   return [JSON.stringify(def.value)]\n    case 'regex':     return [`/${def.source}/`]\n    case 'keywords':  return def.words.map(w => JSON.stringify(w))\n    case 'label':     return [def.label]\n    case 'choice':    return def.parsers.flatMap(staticExpected)\n    case 'sequence':  return def.parsers.length > 0 ? staticExpected(def.parsers[0]!) : []\n    case 'node':\n    case 'grammar':\n    case 'trivia':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'transform':\n    case 'not':       return staticExpected(def.parser)\n    case 'lazy':      return staticExpected(def.thunk())\n    default:          return []\n  }\n}\n\n/**\n * Required-token combinator. Tries `combinator`; on success returns it verbatim.\n * On failure it does NOT fail \u2014 it records a {@link ParseError} (the statically\n * derived expected set, or `label` when given) into `ctx._errors` and RECOVERS IN\n * PLACE, returning a zero-width success so the enclosing sequence continues as if\n * the token were present.\n *\n * Use it to mark required delimiters/terminators (`}` `)` `;`, a selector before a\n * block) so a missing one is reported with position + expectation rather than\n * aborting the whole parse or being silently swallowed by a catch-all.\n *\n *   sequence(literal('{'), declList, expect(literal('}'), '}'))\n *\n * Errors are only collected when the parse runs with `{ recover: true }`; without\n * it, expect() still recovers in place but records nothing (zero overhead beyond\n * the inner attempt).\n */\nexport function expect<T>(combinator: Combinator<T>, label?: string): Combinator<T | ParseError> {\n  const expected = label !== undefined ? [label] : staticExpected(combinator)\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'expect',\n    _meta: meta,\n    _def: { tag: 'expect', parser: combinator as Combinator<unknown>, label, expected },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n      const error: ParseError = { _tag: 'parseError', span: { start: pos, end: pos }, expected }\n      ctx._errors?.push(error)\n      return { ok: true, value: error, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseFail, ParseContext } from '../types.ts'\n\n/**\n * Returns the set of expected tokens at the given cursor offset.\n * Useful for implementing IDE completions.\n *\n * Runs the parser on input truncated at `offset` with a probe that tracks the\n * highest-position failure seen, even when sepBy/many backtrack past the cursor.\n * Returns the expected tokens from that deepest failure.\n *\n * Returns an empty array when the input up to `offset` parses completely\n * with no failures at or before the cursor.\n *\n * The returned strings use the same labels as ParseFail.expected:\n * quoted literals like `\"\\\"{\\\"\"` and regex patterns like `\"/[0-9]+/\"`.\n */\nexport function completionsAt(\n  combinator: Combinator<unknown>,\n  input: string,\n  offset: number,\n): string[] {\n  const probe: { offset: number; best: ParseFail | null } = { offset, best: null }\n  const ctx: ParseContext = { trackLines: false, _probe: probe }\n  const result = combinator.parse(input.slice(0, offset), 0, ctx)\n\n  // If the parser consumed everything up to offset successfully, there is nothing\n  // to complete \u2014 the input is already valid at this position.\n  if (result.ok) return []\n\n  // Use whichever failure (probe or top-level) sits at the deeper position.\n  const best = deeperFail(probe.best, result)\n  return best?.expected ?? []\n}\n\nfunction deeperFail(a: ParseFail | null, b: ParseFail | null): ParseFail | null {\n  if (!a) return b\n  if (!b) return a\n  return a.span.start >= b.span.start ? a : b\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { literal } from './literal.ts'\nimport { regex } from './regex.ts'\nimport { sequence } from './sequence.ts'\nimport { choice } from './choice.ts'\nimport { many } from './repeat.ts'\nimport { transform } from './map.ts'\nimport { expect } from './expect.ts'\nimport { any } from './first-set.ts'\nimport { ref } from './ref.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type ScanToOptions = {\n  /** Parsers that match \"container\" regions to skip over intact (balanced parens, strings, comments\u2026) */\n  skip?: Combinator<unknown>[]\n  /**\n   * If true, reaching EOF without finding the sentinel is a success \u2014 returns\n   * everything consumed so far. Default false (fail at EOF).\n   */\n  orEOF?: boolean\n}\n\n/**\n * Consume input up to (but not including) the sentinel, skipping over any\n * \"hole\" patterns in order so their contents are never mistaken for the sentinel.\n *\n * Returns the consumed text as a string. The sentinel is NOT consumed.\n * Fails if the sentinel is never found (unless orEOF is true).\n *\n *   const selector = scanTo(literal('{'), {\n *     skip: [cssComment, stringLit, balanced('(', ')'), balanced('[', ']')],\n *   })\n */\nexport function scanTo(\n  sentinel: Combinator<unknown>,\n  { skip = [], orEOF = false }: ScanToOptions = {},\n): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'scanTo',\n    _meta: meta,\n    _def: { tag: 'scanTo', sentinel, skip, orEOF },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      let cur = pos\n\n      // Sentinel checks and skip scans must not emit CST children of their own \u2014\n      // scanTo represents the whole scanned span as one leaf. Probe them with a\n      // collector-free context so their internal literal()/regex() don't push.\n      // The error channel IS forwarded, so a committed skipper (e.g. balanced()\n      // whose open delimiter was consumed) can still report an unmatched close.\n      const probeCtx: ParseContext = {\n        trackLines: ctx.trackLines,\n        state: ctx.state,\n        ...(ctx._errors !== undefined ? { _errors: ctx._errors } : {}),\n      }\n\n      // Record the scanned text as a CSTLeaf so buildNode-driven grammars can\n      // see it in children/rawChildren (it would otherwise be lost \u2014 only the\n      // returned value carries it). Skipped when no collector is active.\n      const emit = (end: number) => {\n        if (end > pos && cstCaptureActive(ctx)) {\n          const leaf = { _tag: 'leaf', value: input.slice(pos, end), span: { start: pos, end } }\n          pushCstLeaf(ctx, leaf)\n        }\n      }\n\n      while (cur < input.length) {\n        // Check sentinel \u2014 if it matches here, stop and return consumed text.\n        const s = sentinel.parse(input, cur, probeCtx)\n        if (s.ok) {\n          emit(cur)\n          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n        }\n\n        // Try each skipper in order; take first that advances.\n        let advanced = false\n        for (const skipper of skip) {\n          const r = skipper.parse(input, cur, probeCtx)\n          if (r.ok && r.span.end > cur) {\n            cur = r.span.end\n            advanced = true\n            break\n          }\n        }\n\n        // Nothing matched \u2014 consume one character and continue.\n        if (!advanced) cur++\n      }\n\n      // Reached EOF without finding sentinel.\n      if (orEOF) {\n        emit(cur)\n        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n      }\n      const sentDef = sentinel._def\n      const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']\n      return { ok: false, expected, span: { start: pos, end: cur } }\n    },\n  }\n}\n\n/**\n * Match a balanced open/close pair, skipping over any holes inside.\n * Returns the full matched text including delimiters.\n *\n *   const parenGroup = balanced('(', ')', { skip: [comment, stringLit] })\n */\nexport function balanced(\n  open: string,\n  close: string,\n  options: ScanToOptions = {},\n): Combinator<string> {\n  // The interior scan must skip NESTED same-delimiter pairs so depth is counted \u2014\n  // otherwise `{{x}}` stops at the first `}`. `self` references this balanced\n  // combinator; added to the interior scan's skip list, a nested `open` is\n  // consumed intact (recursively) before the scan looks for the matching `close`.\n  const self = ref<string>()\n  const skips = options.skip ?? []\n  // PREDICTIVE interior \u2014 no char-walk. The body is `many(choice(self, \u2026skips,\n  // contentRun))`, where contentRun is a regex of chars that are NOT this pair's\n  // delimiters and NOT the start of any skip (so a string/comment arm still wins\n  // its position). At any other character \u2014 a stray close, or a *different* bracket\n  // type \u2014 no arm matches, `many` stops, and the required close (expect()) reports\n  // \"expected <close>\". So an unmatched open, a cross-type close `(a]`, and a stray\n  // close all surface as errors; nothing is silently swallowed. Well-formed input\n  // is consumed identically.\n  const stop = new Set<string>([open, close])\n  let bounded = true\n  for (const sk of skips) {\n    const cs = firstSetClassChars(sk)\n    if (cs === null) { bounded = false; break }\n    for (const ch of cs) stop.add(ch)\n  }\n  const cls = [...stop].map(escapeClassChar).join('')\n  // A run when every skip's start is bounded (fast); else one char at a time so a\n  // skip arm always gets the chance to match at its position.\n  const content = bounded\n    ? regex(new RegExp(`[^${cls}]+`))\n    : regex(new RegExp(`[^${escapeClassChar(open)}${escapeClassChar(close)}]`))\n  const inner = many(choice(self, ...skips, content))\n  const combi = transform(\n    sequence(literal(open), inner, expect(literal(close), close)),\n    // parts: strings (content/self) or arrays (a sequence-shaped skip) or a\n    // ParseError (recovered close). `c` is the close string or a ParseError.\n    ([o, parts, c]) => o + (parts as unknown[]).map(p => typeof p === 'string' ? p : Array.isArray(p) ? p.join('') : '').join('') + (typeof c === 'string' ? c : ''),\n  )\n  // Provide the callback source so the macro can inline this library-internal\n  // transform (codegen derives map-fn sources from def.fnSrc).\n  if (combi._def.tag === 'transform') {\n    combi._def.fnSrc = '([o, parts, c]) => o + parts.map(p => typeof p === \"string\" ? p : Array.isArray(p) ? p.join(\"\") : \"\").join(\"\") + (typeof c === \"string\" ? c : \"\")'\n  }\n  self.define(combi as Combinator<string>)\n  return combi\n}\n\n/**\n * The characters a combinator can START with, as char-class members \u2014 or null if\n * its first set is unbounded ('any') or too broad to be a delimiter. Used by\n * balanced() to keep a content run from eating the start of a skip.\n */\nfunction firstSetClassChars(c: Combinator<unknown>): string[] | null {\n  const fs = c._meta.firstSet\n  if (fs.kind === 'empty') return []\n  if (fs.kind !== 'ranges') return null\n  const out: string[] = []\n  for (const { lo, hi } of fs.ranges) {\n    if (hi - lo > 8) return null\n    for (let cp = lo; cp <= hi; cp++) out.push(String.fromCodePoint(cp))\n  }\n  return out\n}\n\nfunction escapeClassChar(ch: string): string {\n  return ch.replace(/[\\\\\\]^-]/g, '\\\\$&')\n}\n", "/**\n * Functional incremental document \u2014 incremental re-parse over a rules() registry.\n */\nimport type { ParseContext, ParseFail, ParseResult } from '../types.ts'\nimport type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts'\n\n/** A single compiled (or interpreted) rule: parse from `pos`, producing node `N`. */\nexport type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>\n\n/** Rule name \u2192 parser function. This is exactly the shape `rules()` returns. */\nexport type Registry<N> = Record<string, RuleFn<N>>\n\nexport type FunctionalDocOptions<N extends NodeLike> = {\n  /** Initial grammar state threaded into ctx.state for the root parse. */\n  state?: unknown\n  /**\n   * Reconstruct a parent node with one child replaced (used when grafting a\n   * re-parsed subtree into its ancestors). Defaults to a shallow spread, which\n   * works for plain-object nodes; class-instance ASTs should supply their own.\n   */\n  rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N\n}\n\nexport interface FunctionalDoc<N extends NodeLike> {\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n  /**\n   * Incrementally re-parse after a text change. `from`/`to` are byte offsets in\n   * the OLD input; `replacement` fills that range (editor change-event shape).\n   */\n  edit(from: number, to: number, replacement: string): FunctionalDoc<N>\n}\n\n// ---------------------------------------------------------------------------\n// Tree navigation (generic over NodeLike \u2014 no class, no CST assumptions)\n// ---------------------------------------------------------------------------\n\ntype FoundNode<N extends NodeLike> = { node: N; path: number[] }\n\nfunction isNode(x: unknown): x is NodeLike {\n  return typeof x === 'object' && x !== null && (x as { _tag?: string })._tag === 'node'\n}\n\nfunction findContaining<N extends NodeLike>(node: N, pos: number, path: number[] = []): FoundNode<N> | null {\n  for (let i = 0; i < node.children.length; i++) {\n    const child = node.children[i]!\n    if (!isNode(child)) continue\n    if (child.span.start <= pos && pos < child.span.end) {\n      const inner = findContaining(child as N, pos, [...path, i])\n      return inner ?? { node: child as N, path: [...path, i] }\n    }\n  }\n  return null\n}\n\nfunction ancestorsAt<N extends NodeLike>(root: N, path: number[]): N[] {\n  const ancestors: N[] = [root]\n  let cur: N = root\n  for (const idx of path.slice(0, -1)) {\n    const child = cur.children[idx]\n    if (!child || !isNode(child)) break\n    ancestors.push(child as N)\n    cur = child as N\n  }\n  return ancestors\n}\n\nfunction replaceAtPath<N extends NodeLike>(\n  rebuild: NonNullable<FunctionalDocOptions<N>['rebuild']>,\n  root: N,\n  path: number[],\n  newNode: N,\n): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const newChildren = [...root.children] as Array<N | CSTLeaf | CSTError>\n  newChildren[idx] = rest.length === 0\n    ? newNode\n    : replaceAtPath(rebuild, root.children[idx] as N, rest, newNode)\n  return rebuild(root, newChildren)\n}\n\nfunction defaultRebuild<N extends NodeLike>(node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>): N {\n  return { ...node, children } as N\n}\n\n// ---------------------------------------------------------------------------\n// Document\n// ---------------------------------------------------------------------------\n\nclass FunctionalDocImpl<N extends NodeLike> implements FunctionalDoc<N> {\n  private readonly _registry: Registry<N>\n  private readonly _rootRule: string\n  private readonly _opts: FunctionalDocOptions<N>\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n\n  constructor(\n    registry: Registry<N>,\n    rootRule: string,\n    opts: FunctionalDocOptions<N>,\n    tree: N | null,\n    errors: ParseFail[],\n    input: string,\n  ) {\n    this._registry = registry\n    this._rootRule = rootRule\n    this._opts = opts\n    this.tree = tree\n    this.errors = errors\n    this.input = input\n  }\n\n  edit(from: number, to: number, replacement: string): FunctionalDoc<N> {\n    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to)\n    const reparse = () => makeFunctionalDoc(this._registry, this._rootRule, newInput, this._opts)\n\n    if (!this.tree) return reparse()\n\n    const delta = replacement.length - (to - from)\n    const found = findContaining(this.tree, from)\n    if (!found) return reparse()\n\n    // Try the innermost containing rule first, then widen outward.\n    const ancestors = ancestorsAt(this.tree, found.path)\n    const candidates: FoundNode<N>[] = [found]\n    const pathCopy = [...found.path]\n    for (let i = ancestors.length - 2; i >= 0; i--) {\n      pathCopy.pop()\n      candidates.push({ node: ancestors[i + 1]!, path: [...pathCopy] })\n    }\n\n    const rebuild = this._opts.rebuild ?? defaultRebuild\n    for (const { node, path } of candidates) {\n      const ruleFn = this._registry[node.type]\n      if (!ruleFn) continue\n      const ctx: ParseContext = { trackLines: false, state: node.state }\n      const r = ruleFn(newInput, node.span.start, ctx)\n      if (!r.ok) continue\n      if (r.span.end === node.span.end + delta) {\n        const newTree = replaceAtPath(rebuild, this.tree, path, r.value)\n        return new FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput)\n      }\n    }\n\n    return reparse()\n  }\n}\n\n/**\n * Parse `input` from `rootRule` and wrap the result in a FunctionalDoc that can\n * be incrementally re-parsed via `.edit()`.\n */\nexport function makeFunctionalDoc<N extends NodeLike>(\n  registry: Registry<N>,\n  rootRule: string,\n  input: string,\n  opts: FunctionalDocOptions<N> = {},\n): FunctionalDoc<N> {\n  const ruleFn = registry[rootRule]\n  if (!ruleFn) throw new Error(`No rule '${rootRule}' in registry`)\n  const ctx: ParseContext = { trackLines: false, state: opts.state }\n  const r: ParseResult<N> = ruleFn(input, 0, ctx)\n  if (r.ok) {\n    return new FunctionalDocImpl(registry, rootRule, opts, r.value, [], input)\n  }\n  return new FunctionalDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input)\n}\n", "import type { Span } from '../types.ts'\n\n/** One captured trivia token (a whitespace run or a comment) with its source span. */\nexport type TriviaToken = { readonly value: string; readonly span: Span }\n\n/**\n * Before/after offset index of captured trivia. Built from a tree whose nodes\n * carry a `triviaLog` property (the flat `[start, end, insertIdx, ...]` array\n * produced by parseman when `parser({ captureTrivia: true })` wraps a `node()` grammar).\n *\n *   index.before.get(node.span.start)  // trivia immediately before a node\n *   index.after.get(node.span.end)     // trivia immediately after a node\n *\n * A given trivia entry is registered under BOTH the following item's start\n * (`before`) and the preceding item's end (`after`), so either lookup finds it.\n */\nexport type TriviaIndex = {\n  readonly before: Map<number, TriviaToken[]>\n  readonly after: Map<number, TriviaToken[]>\n}\n\ntype Spanned = { readonly span: Span }\ntype NodeWithTrivia = {\n  readonly span?: Span\n  readonly children?: ReadonlyArray<unknown>\n  readonly rawChildren?: ReadonlyArray<Spanned>\n  readonly triviaLog?: readonly number[]\n}\n\nfunction merge(map: Map<number, TriviaToken[]>, key: number, run: TriviaToken[]): void {\n  if (run.length === 0) return\n  const existing = map.get(key)\n  if (existing) existing.push(...run)\n  else map.set(key, [...run])\n}\n\n/**\n * Options for trailing/leading trivia at the document boundary. A repeating root\n * (e.g. `many()`) rolls back the trivia after its last item \u2014 it's \"trailing\" and\n * belongs to the enclosing context, which at the document root is the document\n * itself. Pass `{ trivia }` to re-scan and register that boundary trivia,\n * so a round-trippable trivia map isn't missing the run before EOF.\n */\nexport type TriviaIndexOptions = {\n  /**\n   * A regex matching ONE trivia token (a whitespace run or a comment). Applied\n   * repeatedly to tokenize the boundary trivia. Each match becomes one token, so\n   * write it to match a maximal run, e.g.\n   * `/[ \\t\\n\\r\\f]+|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//`.\n   */\n  trivia: RegExp\n}\n\n/**\n * Walk a tree whose nodes carry `triviaLog` (from `node()` + `captureTrivia`)\n * and build a before/after trivia index. Each node must have\n * `triviaLog: readonly number[]` (flat `[start, end, insertIdx, \u2026]` \u2014\n * three numbers per entry) and `rawChildren` (structural items with `.span`).\n * `input` is the source string used to materialize trivia values.\n *\n * With `opts`, also captures leading trivia (before the root's content) and\n * trailing trivia (after it, up to EOF) \u2014 the document boundaries a repeating\n * root rolls back.\n */\nexport function buildTriviaIndex(root: unknown, input = '', opts?: TriviaIndexOptions): TriviaIndex {\n  const before = new Map<number, TriviaToken[]>()\n  const after = new Map<number, TriviaToken[]>()\n\n  const visit = (node: NodeWithTrivia): void => {\n    const log = node.triviaLog\n    const raw = node.rawChildren\n\n    if (log && log.length && raw) {\n      for (let i = 0; i < log.length; i += 3) {\n        const tStart = log[i]!, tEnd = log[i + 1]!, insertIdx = log[i + 2]!\n        if (tEnd <= tStart) continue\n        const run: TriviaToken[] = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }]\n        const next = raw[insertIdx]\n        if (next) merge(before, next.span.start, run)\n        const prev = insertIdx > 0 ? raw[insertIdx - 1] : undefined\n        if (prev) merge(after, prev.span.end, run)\n      }\n    }\n\n    const ch = node.children\n    if (ch) {\n      for (const c of ch) {\n        if (typeof c === 'object' && c !== null && (c as NodeWithTrivia).children !== undefined) {\n          visit(c as NodeWithTrivia)\n        }\n      }\n    }\n  }\n\n  if (root) visit(root as NodeWithTrivia)\n\n  // Document-boundary trivia: re-scan leading (offset 0) and trailing (root end\n  // \u2192 EOF) trivia that a repeating root rolled back.\n  if (opts && input) {\n    const rootSpan = (root as NodeWithTrivia | null)?.span\n    const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, '') + 'y')\n    const scanFrom = (from: number): TriviaToken[] => {\n      const run: TriviaToken[] = []\n      let pos = from\n      re.lastIndex = pos\n      let m = re.exec(input)\n      while (m && m.index === pos && m[0].length > 0) {\n        run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } })\n        pos += m[0].length\n        re.lastIndex = pos\n        m = re.exec(input)\n      }\n      return run\n    }\n\n    if (rootSpan && rootSpan.start > 0) {\n      const lead = scanFrom(0)\n      if (lead.length) merge(before, rootSpan.start, lead)\n    }\n    const end = rootSpan ? rootSpan.end : 0\n    if (end < input.length) {\n      const trail = scanFrom(end)\n      if (trail.length) {\n        merge(after, end, trail)\n        merge(before, end + trail.reduce((n, t) => n + (t.span.end - t.span.start), 0), trail)\n      }\n    }\n  }\n\n  return { before, after }\n}\n", "/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */\nexport type TriviaEntriesView = {\n  readonly length: number\n  readonly labels: readonly string[] | undefined\n  readonly stride: number\n  start(i: number): number\n  end(i: number): number\n  kindIndex(i: number): number | undefined\n  kind(i: number): string | undefined\n  text(i: number, input: string): string\n}\n\nfunction entryOffset(i: number, stride: number): number {\n  return i * stride\n}\n\n/**\n * Wrap a flat trivia log. Stride is inferred from `labels`:\n * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)\n * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)\n */\nexport function triviaEntries(\n  log: readonly number[],\n  labels?: readonly string[],\n  opts?: { nodeLog?: boolean },\n): TriviaEntriesView {\n  const baseStride = opts?.nodeLog ? 3 : 2\n  const stride = labels ? baseStride + 1 : baseStride\n  const length = Math.floor(log.length / stride)\n\n  return {\n    length,\n    labels,\n    stride,\n    start(i) {\n      return log[entryOffset(i, stride)]!\n    },\n    end(i) {\n      return log[entryOffset(i, stride) + 1]!\n    },\n    kindIndex(i) {\n      if (!labels) return undefined\n      return log[entryOffset(i, stride) + baseStride]\n    },\n    kind(i) {\n      const ki = labels ? log[entryOffset(i, stride) + baseStride] : undefined\n      return ki !== undefined ? labels![ki] : undefined\n    },\n    text(i, input) {\n      const s = log[entryOffset(i, stride)]!\n      const e = log[entryOffset(i, stride) + 1]!\n      return input.slice(s, e)\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["node", "parser", "trivia", "trivia", "tr", "result", "parser", "unwrapTrivia", "trivia", "escapeRegExp", "body", "trivia", "r", "litCond", "parser", "fnName", "mv", "label", "skip", "emit", "node", "node"]
 }