parseman 0.12.0 → 0.13.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/compiler/build-arity.ts", "../src/combinators/node.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/combinators/expect.ts", "../src/compiler/scannable-run.ts", "../src/compiler/trivia-fast-path.ts", "../src/compiler/scannable-terminal.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/combinators/recover-list.ts", "../src/functional/doc.ts", "../src/cst/trivia-index.ts", "../src/cst/walk.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      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      // Require the closing `*/`; an unterminated comment is NOT trivia (the\n      // `/\\*\u2026\\*/` regex arm would fail), so stop here without consuming it \u2014\n      // matching scanLabeledTriviaChunks and the compiled delimited scan.\n      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {\n        const start = pos\n        pos = j + 2\n        chunks.push({ start, end: pos, kindIndex: commentKind })\n        continue\n      }\n      break\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 { ParserDef } from '../types.ts'\n\n/**\n * Per-node CST-trivia (4th build arg) and state-clone (5th build arg) capture is\n * dead work when the build never declares those formal params. This module derives\n * a build's *confirmed* formal-parameter arity so all three eval paths (interpreter,\n * compiler, macro) can elide that capture identically.\n *\n * Conservative by construction: any source we can't confidently parse \u2014 rest params,\n * destructuring, `arguments`, an unrecognized shape \u2014 yields `null` (arity unknown),\n * and callers KEEP full capture. We only ever return a number when the parameter list\n * is a plain comma-separated list of simple identifiers.\n */\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\n/** Matches the formal-parameter list of an arrow or function build, capturing its inner text. */\nconst PARAM_LIST_RE =\n  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`\n  /^(?:function\\b[^(]*\\(([^)]*)\\)|\\(([^)]*)\\)\\s*=>|([A-Za-z_$][\\w$]*)\\s*=>)/\n\n/**\n * A confirmable formal param: a plain identifier, optionally `?`-optional and\n * optionally carrying a TypeScript type annotation (`c`, `c?`, `c: any`,\n * `c?: Foo`). The build source is sliced verbatim from the (possibly TS) grammar\n * source, so typed params must be recognized or every typed grammar keeps full\n * capture. Type annotations containing a comma (generics/tuples/object types) are\n * split apart by the caller's `,`-split into non-matching fragments \u2192 `null`\n * (conservative). No `=` (default) is accepted \u2014 defaults stay unconfirmed.\n */\nconst CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\\w$]*\\s*\\??\\s*(?::[^,=]+)?$/\n\n/**\n * Confirmed count of simple formal parameters the build declares, or `null` when the\n * source can't be parsed into a plain identifier list (\u2192 caller keeps full capture).\n */\nexport function confirmedBuildArity(src: string): number | null {\n  const s = src.trim()\n  const m = PARAM_LIST_RE.exec(s)\n  if (!m) return null\n\n  // Single-ident arrow: `x => ...` \u2192 exactly one param.\n  if (m[3] !== undefined) return 1\n\n  const inner = (m[1] ?? m[2] ?? '').trim()\n  if (inner === '') return 0\n\n  // Reject anything that isn't a flat list of simple identifiers. A rest param\n  // (`...args`), destructuring (`{a}`, `[a]`), or default (`a = 1`) all appear here.\n  const parts = inner.split(',')\n  for (const part of parts) {\n    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null\n  }\n\n  // A stray `arguments` reference defeats formal-arity reasoning entirely; only a\n  // full-source scan can rule it out. Cheap guard against the obvious cases.\n  if (/\\barguments\\b/.test(s)) return null\n\n  return parts.length\n}\n\n/** Build reads the 4th (triviaLog) arg? Unknown/unparseable \u2192 true (keep capture). */\nexport function buildReadsTrivia(def: NodeDef): boolean {\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 4\n}\n\n/** Build reads the 5th (state) arg? Unknown/unparseable \u2192 true (keep state clone). */\nexport function buildReadsState(def: NodeDef): boolean {\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 5\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParserDef } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\nimport { buildReadsTrivia, buildReadsState } from '../compiler/build-arity.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\n/**\n * Options for `node()`.\n * - `collapse` \u2014 a structural wrapper rule (a selector list, an\n *   expression-precedence level, \u2026) that IS its single child when it captured\n *   exactly one. With `collapse: true`, a one-child match returns that child\n *   directly (a leaf unwrapped to its string value, a sub-node as-is) and\n *   `build` is NOT called; zero or two-plus children go through `build`\n *   normally. Lets a grammar keep readable layered rules without paying a build\n *   call per collapsing layer \u2014 and without hand-writing\n *   `if (children.length === 1) return children[0]` in every wrapper builder.\n */\nexport type NodeOptions = { collapse?: boolean }\n\n/** A captured child's value form: a leaf unwraps to its string value, else as-is. */\nfunction collapseChild(child: unknown): unknown {\n  return child !== null && typeof child === 'object' && (child as { _tag?: string })._tag === 'leaf'\n    ? (child as { value: unknown }).value\n    : child\n}\n\nexport function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>, opts?: NodeOptions): Combinator<N> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const collapse = opts?.collapse === true\n  const def: Extract<ParserDef, { tag: 'node' }> = collapse\n    ? { tag: 'node', type, parser: combinator, build, collapse: true }\n    : { tag: 'node', type, parser: combinator, build }\n  // Arity-gated elision \u2014 decided once, identically to the compiler (build-arity.ts).\n  // When the build never reads the trivia (4th) arg, disable per-node CST-trivia\n  // capture for the inner scope; when it never reads state (5th), skip the state clone.\n  const capturesTrivia = buildReadsTrivia(def)\n  const clonesState = buildReadsState(def)\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      // Short-circuit the per-node trivia push (scanTrivia gates on captureTrivia)\n      // without touching the global _triviaLog, which is committed independently.\n      if (!capturesTrivia) ctx.captureTrivia = false\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      // collapse: a single captured child IS the value \u2014 skip build.\n      const built: unknown = collapse && children.length === 1\n        ? collapseChild(children[0])\n        : build(\n          children, rawChildren, r.span, triviaLog,\n          clonesState && ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined,\n        )\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 as N, 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", "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", "/**\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]>; minOne: boolean }\n  | { kind: 'ident'; head: Array<[number, number]>; tail: Array<[number, number]> }\n  | { kind: 'until'; open: number[]; stop: Array<[number, number]> }\n  | { kind: 'delimited'; open: number[]; close: number[] }\n  // <q>(?:[^<q>\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with backslash escapes.\n  // `excluded` = the body's negated class (always contains the quote + backslash,\n  // maybe a newline); `escLineTerm` = whether `\\\\` may be followed by a line\n  // terminator (`\\\\[\\s\\S]` \u2192 true, `\\\\.` \u2192 false, since `.` excludes them).\n  | { kind: 'string'; quote: number; excluded: Array<[number, number]>; escLineTerm: boolean }\n\n/** Backslash (`\\`) code point \u2014 the escape lead char in string shapes. */\nexport const BACKSLASH = 92\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/**\n * ASCII code-point ranges for the shorthand classes we can lower safely. `\\d`\n * and `\\w` are ASCII-only in the default (non-`u`) engine, so they map to fixed\n * ranges. `\\s` is deliberately absent \u2014 it includes Unicode whitespace\n * (`\\u00a0`, `\\u1680`, \u2026) that a fixed ASCII range would silently drop.\n */\nfunction shorthandRanges(ch: 'd' | 'w'): Array<[number, number]> {\n  return ch === 'd'\n    ? [[48, 57]]\n    : [[48, 57], [65, 90], [97, 122], [95, 95]]\n}\n\ntype ClassAtom = { cp: number } | { set: Array<[number, number]> }\n\n/**\n * Parse a regex char-class body (chars between `[` and `]`) to code-point ranges.\n * `\\d`/`\\w` expand to their ASCII ranges; other letter escapes (`\\s`, `\\D`,\n * `\\W`, `\\S`, `\\b`, \u2026) return null rather than being mis-read as literal letters.\n */\nfunction parseClassRanges(body: string): Array<[number, number]> | null {\n  const ranges: Array<[number, number]> = []\n  let i = 0\n  const readAtom = (): ClassAtom | 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      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e]! }\n      if (e === 'd' || e === 'w') return { set: shorthandRanges(e) }\n      // Any other letter escape is a class we can't safely lower (\\s, \\D, \u2026).\n      if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      return { cp: e.codePointAt(0)! }\n    }\n    i += ch.length\n    return { cp: ch.codePointAt(0)! }\n  }\n  while (i < body.length) {\n    const lo = readAtom()\n    if (lo === null) return null\n    if ('set' in lo) {\n      ranges.push(...lo.set)\n      continue\n    }\n    if (body[i] === '-' && body[i + 1] !== undefined && body[i + 1] !== ']') {\n      i += 1\n      const hi = readAtom()\n      if (hi === null || 'set' in hi) return null\n      ranges.push([lo.cp, hi.cp])\n    } else {\n      ranges.push([lo.cp, lo.cp])\n    }\n  }\n  return ranges.length ? ranges : null\n}\n\n/** A single class token (`[...]` or `\\d`/`\\w`) to ranges, or null. Rejects negation. */\nfunction classToRanges(cls: string): Array<[number, number]> | null {\n  if (cls === '\\\\d') return shorthandRanges('d')\n  if (cls === '\\\\w') return shorthandRanges('w')\n  const body = cls.slice(1, -1)\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\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 a quote-delimited string with backslash escapes:\n *   <q>(?:[^\u2026]|\\\\.)*<q>  or  <q>(?:\\\\.|[^\u2026])*<q>   (`?:` optional)\n * where the negated body class contains the quote and the backslash, and the\n * escape body is `.` (no line terminators) or `[\\s\\S]` (any char). Returns null\n * for anything else so the caller falls back to `regex.exec`.\n */\nfunction parseStringShape(source: string): ScanShape | null {\n  const q = source[0]\n  if (q === undefined || q === '\\\\' || META.has(q)) return null\n  if (source.length < 3 || source[source.length - 1] !== q) return null\n  const inner = source.slice(1, -1)\n  const CLS = String.raw`\\[\\^((?:\\\\.|[^\\]])+)\\]`\n  const ESC = String.raw`\\\\\\\\(\\.|\\[\\\\s\\\\S\\]|\\[\\\\S\\\\s\\])`\n  // Two arm orders; `?:` optional. Capture groups differ, so read both out.\n  let body: string | undefined\n  let esc: string | undefined\n  let m = new RegExp(`^\\\\((?:\\\\?:)?${CLS}\\\\|${ESC}\\\\)\\\\*$`).exec(inner)\n  if (m) { body = m[1]; esc = m[2] }\n  else {\n    m = new RegExp(`^\\\\((?:\\\\?:)?${ESC}\\\\|${CLS}\\\\)\\\\*$`).exec(inner)\n    if (m) { esc = m[1]; body = m[2] }\n  }\n  if (body === undefined || esc === undefined) return null\n  const excluded = parseClassRanges(body)\n  if (!excluded) return null\n  const qcp = q.codePointAt(0)!\n  const inSet = (cp: number) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi)\n  if (!inSet(qcp) || !inSet(BACKSLASH)) return null\n  return { kind: 'string', quote: qcp, excluded, escLineTerm: esc !== '.' }\n}\n\n/**\n * Recognize one scannable arm from its regex source, or null if it isn't one of\n * the structural shapes. Order matters: char-class run, ident, string, 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, minOne: m[2] === '+' } : null\n  }\n  // \\d+ / \\w+ / \\d* / \\w* \u2014 a bare shorthand-class run.\n  m = /^\\\\([dw])([+*])$/.exec(source)\n  if (m) {\n    return { kind: 'chars', ranges: shorthandRanges(m[1] as 'd' | 'w'), minOne: m[2] === '+' }\n  }\n  // <head><tail>* \u2014 identifier run: one head char, then a run of tail chars.\n  // Each of head/tail is a `[...]` class or a `\\d`/`\\w` shorthand.\n  m = /^(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dw])(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dw])\\*$/.exec(source)\n  if (m) {\n    const head = classToRanges(m[1]!)\n    const tail = classToRanges(m[2]!)\n    return head && tail ? { kind: 'ident', head, tail } : null\n  }\n  // <q>(?:[^q\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with escapes.\n  const str = parseStringShape(source)\n  if (str) return str\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\n/**\n * Flag-aware wrapper around `parseScanShape`. Lowering to a raw code-point scan\n * assumes default regex semantics, so any flag that changes matching (`i` case\n * folding, `u` surrogate handling, `m`/`s` anchor/dot behavior) disables it.\n * `g`/`y` are stickiness-only and safe.\n */\nexport function scanShapeFromRegex(source: string, flags: string): ScanShape | null {\n  if (/[imsu]/.test(flags)) return null\n  return parseScanShape(source)\n}\n\nexport const 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. */\nexport const 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/** Line-terminator code points `.` does not match (`\\n \\r \\u2028 \\u2029`). */\nexport const LINE_TERMINATORS = [10, 13, 8232, 8233] as const\n\n/** The body-stop chars that abort a string match (excluded set minus quote/backslash). */\nexport function stringHardStop(\n  shape: Extract<ScanShape, { kind: 'string' }>,\n): Array<[number, number]> {\n  return shape.excluded.filter(\n    ([lo, hi]) => !(lo === hi && (lo === shape.quote || lo === BACKSLASH)),\n  )\n}\n\n/** Mints a fresh, unique local variable name (`prefix` + counter). */\nexport type Mint = (prefix?: string) => string\n\n/**\n * The SINGLE source of truth for how a scannable shape matches at `start`. Both\n * the terminal emitter and the trivia scan loop consume this, so no context can\n * silently reinterpret an incomplete match (e.g. an unterminated string):\n *\n *   - `setup`   statements (indented by `ind`) that compute the match.\n *   - `ok`      a boolean expr: did a token match at `start`? (zero-width for\n *               `chars*` counts as a match \u2014 terminals allow it.)\n *   - `end`     the position AFTER the token. **Invariant:** `end === start`\n *               whenever there is no progress (match failed or matched empty),\n *               so the trivia loop can gate purely on `end > start`.\n *\n * `firstChar`, when supplied, is an expression already equal to\n * `charCodeAt(start)` (the trivia loop reads it once and shares it).\n */\nexport type ShapeMatch = { setup: string[]; ok: string; end: string }\n\nconst codeAt = (start: string, firstChar?: string): string =>\n  firstChar ?? `input.charCodeAt(${start})`\n\nexport function emitShapeMatch(\n  shape: ScanShape,\n  start: string,\n  mint: Mint,\n  ind: string,\n  firstChar?: string,\n): ShapeMatch {\n  if (shape.kind === 'chars') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.ranges)})) ${cur}++`,\n      ],\n      // `*` always matches (possibly empty); `+` needs at least one char.\n      ok: shape.minOne ? `${cur} > ${start}` : 'true',\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'ident') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}if (${start} < input.length && (${classCond(codeAt(start, firstChar), shape.head)})) {`,\n        `${ind}  ${cur} = ${start} + 1`,\n        `${ind}  while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.tail)})) ${cur}++`,\n        `${ind}}`,\n      ],\n      ok: `${cur} > ${start}`,\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'until') {\n    const j = mint('_j')\n    const openLen = shape.open.length\n    const openChk = openLen === 1\n      ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n      : litCond(start, shape.open, firstChar)\n    return {\n      setup: [\n        `${ind}let ${j} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n        `${ind}  ${j} = ${start} + ${openLen}`,\n        `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`,\n        `${ind}}`,\n      ],\n      // An open-until-terminator always completes (stop char or EOF), so a matched\n      // open literal is a full match; `end === start` iff the open didn't match.\n      ok: `${j} > ${start}`,\n      end: j,\n    }\n  }\n\n  if (shape.kind === 'string') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const i = mint('_i')\n    const c2 = mint('_c')\n    const hard = stringHardStop(shape)\n    const ltLines = shape.escLineTerm\n      ? []\n      : (() => {\n          const c3 = mint('_c')\n          return [\n            `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,\n            `${ind}      if (${LINE_TERMINATORS.map(t => `${c3} === ${t}`).join(' || ')}) break`,\n          ]\n        })()\n    return {\n      setup: [\n        `${ind}let ${okV} = false`,\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,\n        `${ind}  let ${i} = ${start} + 1`,\n        `${ind}  while (${i} < input.length) {`,\n        `${ind}    const ${c2} = input.charCodeAt(${i})`,\n        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV} = ${i} + 1; break }`,\n        `${ind}    if (${c2} === ${BACKSLASH}) {`,\n        `${ind}      if (${i} + 1 >= input.length) break`,\n        ...ltLines,\n        `${ind}      ${i} += 2`,\n        `${ind}      continue`,\n        `${ind}    }`,\n        ...(hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : []),\n        `${ind}    ${i}++`,\n        `${ind}  }`,\n        `${ind}}`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  // delimited: <open>\u2026<close>, requires the close literal (unclosed \u21D2 no match).\n  const j = mint('_j')\n  const endV = mint('_end')\n  const openLen = shape.open.length\n  const closeLen = shape.close.length\n  const openChk = openLen === 1\n    ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n    : litCond(start, shape.open, firstChar)\n  const closeChk = litCond(j, shape.close)\n  return {\n    setup: [\n      `${ind}let ${j} = ${start}`,\n      `${ind}let ${endV} = ${start}`,\n      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n      `${ind}  ${j} = ${start} + ${openLen}`,\n      `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,\n      `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,\n      `${ind}}`,\n    ],\n    ok: `${endV} > ${start}`,\n    end: endV,\n  }\n}\n\n/**\n * One trivia-loop branch for a shape, dispatched on the current char `c`\n * (= charCodeAt(_e)). Advances `_e` and `continue`s ONLY on real progress\n * (`end > _e`) \u2014 an unterminated delimited/string token leaves `end === _e`, so\n * the loop stops there exactly as the interpreter's `oneOrMore(choice(\u2026))` would.\n */\nexport function scanBranch(shape: ScanShape, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join('\\n')\n}\n\n/**\n * A labeled branch: match one token and, on progress, log its [start, end,\n * kindIndex] trivia chunk. Same completion semantics as scanBranch.\n */\nexport function scanBranchLabeled(shape: ScanShape, kindIndex: number, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [\n    ...m.setup,\n    `    if (${m.end} > _e) {`,\n    `      if (_cap) {`,\n    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,\n    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,\n    `      }`,\n    `      _e = ${m.end}`,\n    `      continue`,\n    `    }`,\n  ].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, type Mint, scanShapeFromRegex, scanBranch, scanBranchLabeled } from './scannable-run.ts'\n\n/** Fresh, collision-free local names for one generated scan function. */\nfunction makeMint(): Mint {\n  let n = 0\n  return (prefix = '_v') => `${prefix}${n++}`\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\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 d = getCoreRegexDef(arm)\n  return d ? scanShapeFromRegex(d.source, d.flags) : 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 directDef = getCoreRegexDef(core)\n  if (directDef) {\n    const shape = scanShapeFromRegex(directDef.source, directDef.flags)\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  const mint = makeMint()\n  return [\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...shapes.map(s => scanBranch(s, mint)),\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 d = getCoreRegexDef(arm.parser)\n    const shape = d ? scanShapeFromRegex(d.source, d.flags) : 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  const mint = makeMint()\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, mint)),\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", "/**\n * Lower scannable regex shapes to tight `charCodeAt` scan loops for terminal\n * `regex()` combinators (PERF_IDEAS \u00A78). Trivia uses the SAME match core via\n * `scannable-run.ts` (`emitShapeMatch`); this module is just the terminal\n * wrapper: run the shared match, fail when it doesn't match, then slice the\n * value. Keeping one match core means terminal and trivia can never disagree on\n * what an incomplete token (unclosed string/comment) means.\n */\nimport { type ScanShape, emitShapeMatch } from './scannable-run.ts'\n\nexport type ScanEmitCtx = {\n  ind: string\n  pos: string\n  valueVar: string\n  /** Emit `if (cond) { failLine }` lines (no trailing blank). */\n  failIf: (cond: string) => string[]\n  fresh: (prefix?: string) => string\n}\n\n/** Emit stmts for one terminal regex match, or null when the shape is unsupported. */\nexport function emitScannableTerminal(\n  shape: ScanShape,\n  c: ScanEmitCtx,\n): { stmts: string[]; endVar: string } | null {\n  const m = emitShapeMatch(shape, c.pos, c.fresh, c.ind)\n  const stmts = [...m.setup]\n  // `chars*` matches unconditionally (possibly empty) \u2014 no failure branch needed.\n  if (m.ok !== 'true') stmts.push(...c.failIf(`!(${m.ok})`))\n  stmts.push(`${c.ind}const ${c.valueVar} = input.slice(${c.pos}, ${m.end})`)\n  return { stmts, endVar: m.end }\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 { staticExpected } from '../combinators/expect.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 { scanShapeFromRegex } from './scannable-run.ts'\nimport { emitScannableTerminal } from './scannable-terminal.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport { buildReadsTrivia, buildReadsState } from './build-arity.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  /** Frozen constant expected-set arrays hoisted to module scope (_fx0 etc.) */\n  expectedDecls: string[]\n  /** Dedup map: array source \u2192 hoisted const name */\n  expectedMap: 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  /** Whether any node() elided trivia capture and needs the shared frozen empty log. */\n  needsEmptyTl?: boolean | undefined\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\n/**\n * Hoist a COMPILE-TIME-CONSTANT expected-set array to a shared, frozen\n * module-level const and return its variable name. Leaf failures (literal,\n * regex, keyword, not, \u2026) have a fixed expected set, so recording it on the hot\n * failure path must NOT allocate a fresh array every time \u2014 a choice arm that\n * misses or a many/sepBy loop that terminates hits this on essentially every\n * token. We store a reference to the shared frozen array instead (one pointer\n * write, zero allocation). It is frozen so accidental in-place mutation throws\n * in tests rather than silently corrupting the shared constant; every path that\n * surfaces `_ctx._fx` as a user-facing ParseResult copies it first (see\n * `resultFromRecorded`), so the public `expected` array stays fresh & mutable.\n */\nfunction hoistExpected(ctx: Ctx, constArrSource: string): string {\n  let name = ctx.expectedMap.get(constArrSource)\n  if (name === undefined) {\n    name = `_fx${ctx.expectedDecls.length}`\n    ctx.expectedDecls.push(`const ${name} = Object.freeze(${constArrSource})`)\n    ctx.expectedMap.set(constArrSource, name)\n  }\n  return name\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  // Record the failure payload before breaking so an enclosing composite\n  // construct can propagate this (deepest) failure verbatim \u2014 parity with the\n  // interpreter, which returns the inner failure result. Recording is skipped\n  // when no consumer will read it (see `ctx.recordFail`): swallowers like\n  // optional/many/sepBy/not never inspect `_ctx._fx`, so a leaf failing inside\n  // them just breaks \u2014 the hot path (loop terminations, first-arm misses) pays\n  // nothing. The direct-return path is the final answer and needs no recording.\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return `break ${ctx.failLabel}`\n    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`\n  }\n  return failReturn(expected, posExpr)\n}\n\n/**\n * Like {@link failBody} but the caller already has an array source. When\n * `constant` (the default), the array is hoisted+frozen (zero-alloc hot path).\n * Pass `constant: false` for dynamic sources (e.g. `_ctx._fx`, a runtime concat)\n * that must be assigned verbatim.\n */\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return `break ${ctx.failLabel}`\n    const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`\n  }\n  // Direct-return (no enclosing fail label). A dynamic source may reference the\n  // shared frozen `_ctx._fx`; copy it so the (possibly frozen) constant never\n  // escapes into a user-facing result. Constant sources are inline literals.\n  if (!constant) return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`\n  return failReturnArr(expectedArr, posExpr)\n}\n\n/** Build a ParseResult from the recorded deepest failure, copying `_fx` so the\n * shared frozen array never escapes into user-facing results. */\nfunction resultFromRecorded(feExpr = '_ctx._fe', fxExpr = '_ctx._fx'): string {\n  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`\n}\n\n/**\n * Propagate the already-recorded deepest failure (`_ctx._fe`/`_ctx._fx`) rather\n * than synthesizing a coarse `[\"node\"]`-style placeholder. Used by composite\n * constructs whose interpreter counterpart returns the inner failure verbatim\n * (node, ref/lazy, withCtx, runtime fallback). `srcCtx` is the ctx var holding\n * the payload (`_ctx`, or a spread child ctx for withCtx).\n */\nfunction propagateFailBody(ctx: Ctx, srcCtx = '_ctx'): string {\n  if (srcCtx !== '_ctx') {\n    // withCtx ran on a spread child ctx; copy its recorded failure back (only\n    // when a consumer will read it) before propagating.\n    if (ctx.failLabel) {\n      if (!ctx.recordFail) return `break ${ctx.failLabel}`\n      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`\n    }\n    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`\n  }\n  // Same-ctx: `_ctx._fx` already holds the deepest failure \u2014 just break/return.\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return resultFromRecorded()\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): 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      // ref/lazy returns the inner failure verbatim \u2014 propagate the recorded\n      // deepest failure (shares _ctx with the named fn), not a \"parser\" label.\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx)),\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// A first code point that keys a switch case is only worth enumerating when the\n// arm dispatches on a few DISCRETE points (keyword/operator first chars). A wide\n// range (a char-class arm like `[a-z]+`) would explode into dozens of `case`\n// labels, so those keep the if/else range-comparison form.\nconst SWITCH_RANGE_LIMIT = 4\nconst SWITCH_MAX_CASES = 48\nconst SWITCH_MIN_CASES = 3\n\n// Benchmark/test-only hook: force the `if/else if` disjoint-dispatch form so it\n// can be A/B'd against the `switch` jump table in the same process. Defaults to\n// off \u2014 production always uses planDisjointDispatch. See bench/codegen-ab.ts.\nlet _forceDisjointIf = false\nexport function __setForceDisjointIf(on: boolean): void { _forceDisjointIf = on }\n\n/**\n * Choose the dispatch form for a *disjoint* choice. Returns per-arm case code\n * points for a `switch` (jump table) when every arm keys off a small discrete\n * set, or `if` to keep the range-comparison `if/else if` chain. The arms are\n * pairwise-disjoint by construction, so each code point maps to exactly one arm.\n */\nfunction planDisjointDispatch(\n  parsers: ReadonlyArray<Combinator<unknown>>,\n): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const p of parsers) {\n    const fs = p._meta.firstSet\n    if (fs.kind !== 'ranges') return { kind: 'if' } // any/empty \u2192 no discrete keys\n    const pts: number[] = []\n    for (const r of fs.ranges) {\n      if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\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 expectedStr = JSON.stringify(`/${def.source}/`)\n  const shape = scanShapeFromRegex(def.source, def.flags)\n  if (shape) {\n    const vv = v(ctx)\n    const scanned = emitScannableTerminal(shape, {\n      ind: ind(ctx),\n      pos,\n      valueVar: vv,\n      failIf: (cond: string) => emitIfFail(ctx, cond, failBody(ctx, expectedStr, pos)),\n      fresh: (prefix?: string) => v(ctx, prefix),\n    })\n    if (scanned) {\n      const stmts = [...scanned.stmts, ...emitLeafCapture(ctx, vv, pos, scanned.endVar)]\n      return { stmts, valueVar: vv, endVar: scanned.endVar }\n    }\n  }\n\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 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\n/**\n * Deep-first `expected` labels for a choice's arms \u2014 the concatenation of each\n * arm's leftmost-leaf expected set, matching what the interpreter collects when\n * no arm's first-set matches (choice.ts) and what expect()'s staticExpected()\n * reports. Falls back to the arm's tag only for arms with no static expectation\n * (e.g. runtime-fallback combinators), preserving the previous behaviour there.\n */\nfunction staticExpectedArr(parsers: Combinator<unknown>[]): string {\n  return JSON.stringify(parsers.flatMap(p => {\n    const e = staticExpected(p)\n    return e.length > 0 ? e : [p._tag]\n  }))\n}\n\n/**\n * True when `p` can only fail at its own start position (its failure span is\n * `{pos,pos}` and its expected set is a fixed label). Such disjoint-choice arms\n * can be emitted inline: their leaf failure already matches the interpreter's\n * `{expected: <label>, span: {pos,pos}}`. Composite arms (sequence, node, \u2026) can\n * fail deeper, so they must be wrapped to re-anchor the span at the choice pos.\n */\nfunction failsAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'literal': case 'regex': case 'keywords': case 'guard': case 'not':\n      return true\n    case 'transform': case 'label':\n      return failsAtStart(d.parser)\n    default:\n      return false\n  }\n}\n\n/**\n * Emit one arm of a disjoint choice, assigning its value/end to `valV`/`endV`.\n * Leaf arms (failsAtStart) are inlined \u2014 their leaf failure already matches the\n * interpreter. Composite arms are wrapped so that on failure the choice reports\n * the arm's deep `expected` (via _ctx._fx) but re-anchors the span at the choice\n * position `pos` \u2014 exactly what the interpreter's disjoint dispatch returns.\n */\nfunction emitDisjointArm(p: Combinator<unknown>, ctx: Ctx, pos: string, valV: string, endV: string): string[] {\n  if (failsAtStart(p)) {\n    const r = emit(p, ctx, pos)\n    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`]\n  }\n  const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n  return [\n    ...stmts,\n    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, '_ctx._fx', pos, false)),\n    `${ind(ctx)}${valV} = ${valVar}`,\n    `${ind(ctx)}${endV} = ${endVar}`,\n  ]\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = staticExpectedArr(def.parsers)\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    const plan = _forceDisjointIf ? { kind: 'if' as const } : planDisjointDispatch(def.parsers)\n\n    // Switch (jump table) when arms key off a few discrete first code points.\n    if (plan.kind === 'switch') {\n      stmts.push(`${ind(ctx)}switch (${codeV}) {`)\n      ctx.indent++\n      for (let i = 0; i < def.parsers.length; i++) {\n        const p = def.parsers[i]!\n        for (const cp of plan.cases[i]!) stmts.push(`${ind(ctx)}case ${cp}:`)\n        stmts.push(`${ind(ctx)}{`)\n        ctx.indent++\n        stmts.push(\n          ...emitDisjointArm(p, ctx, pos, valV, endV),\n          `${ind(ctx)}break`,\n        )\n        ctx.indent--\n        stmts.push(`${ind(ctx)}}`)\n      }\n      stmts.push(`${ind(ctx)}default: ${failArrBody(ctx, allExpected, pos)}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n      return { stmts, valueVar: valV, endVar: endV }\n    }\n\n    // Otherwise if/else if with range comparisons (cheaper for char-class arms).\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      stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV))\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  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  // On no-match the interpreter returns the super-regex arm's failure verbatim\n  // (choice.ts) \u2014 report only the regex's expected, not every classified literal.\n  const regexExpected = JSON.stringify(staticExpected(superParser))\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, regexExpected, 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  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  // For a TOTAL failure we report the concatenation of each tried arm's deep\n  // `expected` (interpreter parity). To keep the hot success path allocation-free\n  // (a choice that ultimately matches must NOT pay for error bookkeeping), each\n  // failed arm snapshots its recorded _ctx._fx REFERENCE into a scalar slot (a\n  // pointer store, no array/spread). The concat array is materialized only in the\n  // rare all-arms-failed branch. Auto-not-rejected arms (which succeed then get\n  // vetoed) leave their slot unset, contributing nothing \u2014 matching choice.ts.\n  const slots = def.parsers.map(() => v(ctx, '_cfx'))\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n    `${ind0}let ${slots.join(', ')}`,\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      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx }`)\n      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`)\n      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx${rollback ? `; ${rollback}` : ''} }`)\n    }\n    stmts.push(`${ind0}}`)\n  }\n  // Concatenate the tried arms' deep expected only when everything failed.\n  const concatExpr = `[${slots.map(s => `...(${s} || [])`).join(', ')}]`\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)))\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, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, 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  // not() fails (at its own pos) when the inner parser SUCCEEDS; the interpreter\n  // reports `not(<innerTag>)` as the expected token \u2014 match that label exactly.\n  const label = JSON.stringify(`not(${def.parser._tag})`)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, label, 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  // Arity-gated elision: when the build provably never reads the trivia (4th) or\n  // state (5th) arg, skip that capture entirely. The mk-inline path reads\n  // `tlV.length` for `localTriviaLen`, so it always keeps trivia capture.\n  const capturesTrivia = mkType !== null || buildReadsTrivia(def)\n  const clonesState = buildReadsState(def)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const tlV = capturesTrivia ? v(ctx, '_tl') : '_EMPTY_TL'\n  if (!capturesTrivia) ctx.needsEmptyTl = true\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  const allocStmt = capturesTrivia\n    ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`\n    : `${i}const ${chV} = [], ${rawV} = []`\n  // When not capturing, set _ctx._cstTriviaLog = undefined so inner trivia terminals'\n  // `if (_ctx._cstTriviaLog !== undefined)` guard short-circuits (no per-token push).\n  const innerTl = capturesTrivia ? tlV : 'undefined'\n  const stmts: string[] = [\n    allocStmt,\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 = ${innerTl}`,\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  // node() returns the inner failure verbatim (interpreter parity) \u2014 propagate\n  // the recorded deepest failure, not a coarse [\"node\"] at the node's start.\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)))\n\n  let stV = 'undefined'\n  if (clonesState) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  }\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  // collapse: a single captured child IS the value (leaf \u2192 its string, else as-is);\n  // build is skipped (short-circuited by the ternary). Mirrors node.ts.\n  const finalExpr = def.collapse\n    ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`\n    : ndExpr\n  stmts.push(\n    `${i}const ${ndV} = ${finalExpr}`,\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  // The runtime parser IS the real combinator, so its result is exactly the\n  // interpreter's \u2014 record its failure payload and propagate it verbatim (only\n  // when a consumer will read it).\n  const failStmt = ctx.failLabel\n    ? (ctx.recordFail\n        ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }`\n        : `break ${ctx.failLabel}`)\n    : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failStmt),\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)\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: ${JSON.stringify(staticExpected(def.parser))} }`,\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          // withCtx runs on a spread child ctx \u2014 copy its recorded failure back\n          // and propagate the inner failure verbatim (interpreter parity).\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx, rv)),\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    expectedDecls: [],\n    expectedMap: 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  const emptyTlDecls = ctx.needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []\n\n  const source = [\n    ...emptyTlDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\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    ...emptyTlDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\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    expectedDecls: [],\n    expectedMap: 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.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : '',\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.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 emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : ''\n  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    emptyTlDecl,\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.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'\nimport { staticExpected } from './expect.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  // Precompute the expected set from the combinator's structure so the ParseError\n  // reports the same expectation in the interpreter and the compiled build (the\n  // compiled path can't rebuild the runtime `expected` array \u2014 same design as expect()).\n  const expected = staticExpected(combinator)\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,\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 { 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 * Automatic list recovery \u2014 tolerant `sepBy` / `many` for editor-grade parsing.\n *\n * Plain `sepBy` / `many` stop at the first item they can't parse. Inside a\n * delimited list (`[ \u2026 ]`, `{ \u2026 }`, an argument list) that means one malformed\n * element truncates the whole list, which is exactly the wrong behavior for an\n * IDE re-parsing broken input. These variants instead skip a bad element up to\n * the next separator (or the list terminator), record a `ParseError` in its\n * place, and keep going \u2014 so the rest of the list still parses.\n *\n * They are built entirely from existing combinators (`recover`, `sepBy`, `many`,\n * `not`, `sequence`, `transform`), so the compiler and CST capture handle them\n * with no special cases \u2014 the macro build behaves identically to the interpreter.\n *\n * The `until` terminator (the list's closing delimiter, matched but not consumed)\n * is required: it's how an *empty* list is told apart from a *malformed* first\n * element. `until` must not overlap with what a valid item can start with.\n */\nimport type { Combinator } from '../types.ts'\nimport { sequence } from './sequence.ts'\nimport { choice } from './choice.ts'\nimport { many, sepBy } from './repeat.ts'\nimport { not } from './not.ts'\nimport { recover, type ParseError } from './recover.ts'\nimport { transform } from './map.ts'\n\n/**\n * One tolerant element: fail cleanly at the terminator (so the list can end),\n * otherwise parse the item or recover the junk before it up to `sentinel`.\n */\nfunction tolerantElement<T>(\n  item: Combinator<T>,\n  sentinel: Combinator<unknown>,\n  until: Combinator<unknown>,\n): Combinator<T | ParseError> {\n  const el = transform(\n    sequence(not(until), recover(item, sentinel)),\n    ([, value]) => value,\n  )\n  // Let the macro inline this library-internal unwrap instead of embedding the\n  // closure (codegen reads map-fn source from def.fnSrc; see balanced()).\n  if (el._def.tag === 'transform') el._def.fnSrc = '([, value]) => value'\n  return el as Combinator<T | ParseError>\n}\n\n/**\n * Like `sepBy`, but tolerant: a malformed element is skipped up to the next\n * `separator` or `until` and recorded as a `ParseError` in the result array,\n * instead of ending the list. An empty list (next token is `until`) yields `[]`\n * with no error.\n *\n *   const elements = sepByRecover(value, literal(','), literal(']'))\n *   const array = sequence(literal('['), elements, literal(']'))\n *   // \"[1,,3]\" \u2192 [1, ParseError, 3] ; error collected via { recover: true }\n */\nexport function sepByRecover<T>(\n  item: Combinator<T>,\n  separator: Combinator<unknown>,\n  until: Combinator<unknown>,\n): Combinator<(T | ParseError)[]> {\n  const sentinel = choice(separator, until)\n  return sepBy(tolerantElement(item, sentinel, until), separator)\n}\n\n/**\n * Like `many`, but tolerant: junk that isn't a valid item (and isn't the `until`\n * terminator) is skipped up to `until` and recorded as a `ParseError`, instead\n * of stopping the repetition. With no separator to resync on, a bad run is\n * captured as a single error up to the terminator.\n *\n *   const items = manyRecover(statement, literal('}'))\n */\nexport function manyRecover<T>(\n  item: Combinator<T>,\n  until: Combinator<unknown>,\n): Combinator<(T | ParseError)[]> {\n  return many(tolerantElement(item, until, until))\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\ntype SpanChild = { span: { start: number; end: number }; children?: readonly unknown[] }\n\n/**\n * Deep-shift every absolute span in a subtree by `delta`. Used for nodes that\n * sit *after* a length-changing edit: their content didn't change but their\n * offsets moved. Plain-object path only (see `graftAndShift`).\n */\nfunction shiftSpans<T>(child: T, delta: number): T {\n  const c = child as unknown as SpanChild\n  const span = { start: c.span.start + delta, end: c.span.end + delta }\n  if (Array.isArray(c.children)) {\n    return { ...(c as object), span, children: c.children.map((g) => shiftSpans(g, delta)) } as unknown as T\n  }\n  return { ...(c as object), span } as unknown as T\n}\n\n/**\n * Graft `newNode` at `path` for a length-changing edit (`delta !== 0`):\n * children before the edit are shared by reference, the edited child is\n * replaced, children after it are span-shifted by `delta`, and each ancestor's\n * `span.end` grows by `delta`. Absolute-offset trees must touch every node after\n * the edit \u2014 that's inherent \u2014 but everything before it is still shared.\n */\nfunction graftAndShift<N extends NodeLike>(root: N, path: number[], newNode: N, delta: number): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const oldChildren = root.children as ReadonlyArray<N | CSTLeaf | CSTError>\n  const newChildren = oldChildren.map((child, i) => {\n    if (i < idx) return child\n    if (i === idx) {\n      return rest.length === 0 ? newNode : graftAndShift(child as N, rest, newNode, delta)\n    }\n    return shiftSpans(child, delta)\n  })\n  return {\n    ...root,\n    span: { start: root.span.start, end: root.span.end + delta },\n    children: newChildren,\n  } 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        // delta === 0: spans are unchanged, so the spine graft (sharing every\n        // untouched sibling by reference) is already correct.\n        if (delta === 0) {\n          const newTree = replaceAtPath(rebuild, this.tree, path, r.value)\n          return new FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput)\n        }\n        // Length-changing edit: nodes after the edit must have their absolute\n        // spans shifted. A custom `rebuild` can't have its spans shifted safely\n        // (it may be a class instance), so fall back to a full, correct reparse.\n        if (this._opts.rebuild) return reparse()\n        const newTree = graftAndShift(this.tree, path, r.value, delta)\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", "/**\n * Tree traversal for the CST/AST a grammar produces. Pars\u00E9man hands back a plain\n * object tree, so you *can* recurse it yourself \u2014 these helpers save you from\n * re-writing the same recursion for diagnostics, folding, or lowering a tree.\n *\n * Two entry points:\n *   - `walk`          \u2014 imperative depth-first traversal with enter/leave hooks.\n *   - `createVisitor` \u2014 Chevrotain-style dispatch keyed on each node's `type`.\n *\n * Both default to the built-in CST shape (`CSTChild` \u2014 the `node()` / leaf / error\n * union), so with no annotation you get precise typing out of the box. Parsing to\n * a custom AST? Pass your node type as a generic: `walk<MyNode>(root, \u2026)`.\n */\nimport type { CSTChild } from './types.ts'\n\n/**\n * The minimal shape these helpers traverse: a `_tag`, an optional rule `type`,\n * and optional structural `children`. The built-in `CSTChild` satisfies it, and\n * so does any custom AST node (that's what the generic override targets).\n */\nexport type Walkable = {\n  readonly _tag: string\n  readonly type?: string\n  readonly children?: ReadonlyArray<Walkable>\n}\n\nexport interface WalkVisitor<N extends Walkable = CSTChild, C = undefined> {\n  /**\n   * Called on entering a node, before its children. Return `false` to skip\n   * descending into this node's children (`leave` still runs).\n   */\n  enter?(node: N, parent: N | null, ctx: C): boolean | void\n  /** Called on leaving a node, after its children. */\n  leave?(node: N, parent: N | null, ctx: C): void\n}\n\n/**\n * Depth-first traversal. Visits `root`, then each structural child in order.\n * `ctx` is threaded to both hooks unchanged (use it as an accumulator).\n *\n * Defaults to the CST shape; override with `walk<MyNode>(root, \u2026)`:\n *\n *   const idents: string[] = []\n *   walk(tree, {\n *     enter(node) {\n *       if (node._tag === 'leaf') idents.push(node.value)\n *     },\n *   })\n */\nexport function walk<N extends Walkable = CSTChild, C = undefined>(\n  root: N,\n  visitor: WalkVisitor<N, C>,\n  ctx: C = undefined as C,\n): void {\n  const go = (node: N, parent: N | null): void => {\n    const descend = visitor.enter ? visitor.enter(node, parent, ctx) : undefined\n    const children = node.children as ReadonlyArray<N> | undefined\n    if (descend !== false && Array.isArray(children)) {\n      for (const child of children) go(child, node)\n    }\n    visitor.leave?.(node, parent, ctx)\n  }\n  go(root, null)\n}\n\nexport interface VisitApi<R, N extends Walkable = CSTChild> {\n  /** Dispatch a node to its handler (by `type`); returns the handler's result. */\n  visit(node: N): R | undefined\n  /** Visit every structural child, collecting the defined results in order. */\n  visitChildren(node: N): R[]\n}\n\nexport type VisitorHandlers<R, N extends Walkable = CSTChild> = Record<\n  string,\n  (node: N, api: VisitApi<R, N>) => R\n>\n\n/**\n * Build a visitor that dispatches on each node's `type` \u2014 the direct analog of a\n * generated CST-visitor base class. Handlers are keyed by rule name and receive\n * an `api` with `visit` / `visitChildren` to recurse:\n *\n *   const evalExpr = createVisitor<number>({\n *     Num: (n) => Number((n as NumNode).value),\n *     Add: (n, api) => api.visitChildren(n).reduce((a, b) => a + b, 0),\n *   })\n *   const total = evalExpr(tree)\n *\n * Defaults to the CST shape; override the return type and node type together with\n * `createVisitor<number, MyNode>({ \u2026 })`. A node whose `type` has no handler\n * falls through to visiting its children (results discarded), so partial visitors\n * work without listing every rule.\n */\nexport function createVisitor<R = void, N extends Walkable = CSTChild>(\n  handlers: VisitorHandlers<R, N>,\n): (node: N) => R | undefined {\n  const api: VisitApi<R, N> = {\n    visit(node) {\n      const handler = node.type !== undefined ? handlers[node.type] : undefined\n      if (handler) return handler(node, api)\n      api.visitChildren(node)\n      return undefined\n    },\n    visitChildren(node) {\n      const out: R[] = []\n      const children = node.children as ReadonlyArray<N> | undefined\n      if (Array.isArray(children)) {\n        for (const child of children) {\n          const r = api.visit(child)\n          if (r !== undefined) out.push(r)\n        }\n      }\n      return out\n    },\n  }\n  return (node) => api.visit(node)\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", "label", "ind", "j", "openLen", "openChk", "endV", "unwrapTrivia", "trivia", "escapeRegExp", "body", "trivia", "vv", "stmts", "r", "litCond", "label", "parser", "fnName", "mv", "walk", "skip", "emit", "node", "newTree", "node", "node"]
+  "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      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      // Require the closing `*/`; an unterminated comment is NOT trivia (the\n      // `/\\*\u2026\\*/` regex arm would fail), so stop here without consuming it \u2014\n      // matching scanLabeledTriviaChunks and the compiled delimited scan.\n      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {\n        const start = pos\n        pos = j + 2\n        chunks.push({ start, end: pos, kindIndex: commentKind })\n        continue\n      }\n      break\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 { ParserDef } from '../types.ts'\n\n/**\n * Per-node CST-trivia (4th build arg) and state-clone (5th build arg) capture is\n * dead work when the build never declares those formal params. This module derives\n * a build's *confirmed* formal-parameter arity so all three eval paths (interpreter,\n * compiler, macro) can elide that capture identically.\n *\n * Conservative by construction: any source we can't confidently parse \u2014 rest params,\n * destructuring, `arguments`, an unrecognized shape \u2014 yields `null` (arity unknown),\n * and callers KEEP full capture. We only ever return a number when the parameter list\n * is a plain comma-separated list of simple identifiers.\n */\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\n/** Matches the formal-parameter list of an arrow or function build, capturing its inner text. */\nconst PARAM_LIST_RE =\n  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`\n  /^(?:function\\b[^(]*\\(([^)]*)\\)|\\(([^)]*)\\)\\s*=>|([A-Za-z_$][\\w$]*)\\s*=>)/\n\n/**\n * A confirmable formal param: a plain identifier, optionally `?`-optional and\n * optionally carrying a TypeScript type annotation (`c`, `c?`, `c: any`,\n * `c?: Foo`). The build source is sliced verbatim from the (possibly TS) grammar\n * source, so typed params must be recognized or every typed grammar keeps full\n * capture. Type annotations containing a comma (generics/tuples/object types) are\n * split apart by the caller's `,`-split into non-matching fragments \u2192 `null`\n * (conservative). No `=` (default) is accepted \u2014 defaults stay unconfirmed.\n */\nconst CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\\w$]*\\s*\\??\\s*(?::[^,=]+)?$/\n\n/**\n * Confirmed count of simple formal parameters the build declares, or `null` when the\n * source can't be parsed into a plain identifier list (\u2192 caller keeps full capture).\n */\nexport function confirmedBuildArity(src: string): number | null {\n  const s = src.trim()\n  const m = PARAM_LIST_RE.exec(s)\n  if (!m) return null\n\n  // Single-ident arrow: `x => ...` \u2192 exactly one param.\n  if (m[3] !== undefined) return 1\n\n  const inner = (m[1] ?? m[2] ?? '').trim()\n  if (inner === '') return 0\n\n  // Reject anything that isn't a flat list of simple identifiers. A rest param\n  // (`...args`), destructuring (`{a}`, `[a]`), or default (`a = 1`) all appear here.\n  const parts = inner.split(',')\n  for (const part of parts) {\n    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null\n  }\n\n  // A stray `arguments` reference defeats formal-arity reasoning entirely; only a\n  // full-source scan can rule it out. Cheap guard against the obvious cases.\n  if (/\\barguments\\b/.test(s)) return null\n\n  return parts.length\n}\n\n/** Build reads the 4th (triviaLog) arg? Unknown/unparseable \u2192 true (keep capture). */\nexport function buildReadsTrivia(def: NodeDef): boolean {\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 4\n}\n\n/** Build reads the 5th (state) arg? Unknown/unparseable \u2192 true (keep state clone). */\nexport function buildReadsState(def: NodeDef): boolean {\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 5\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParserDef } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\nimport { buildReadsTrivia, buildReadsState } from '../compiler/build-arity.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\n/**\n * Options for `node()`.\n * - `collapse` \u2014 a structural wrapper rule (a selector list, an\n *   expression-precedence level, \u2026) that IS its single child when it captured\n *   exactly one. With `collapse: true`, a one-child match returns that child\n *   directly (a leaf unwrapped to its string value, a sub-node as-is) and\n *   `build` is NOT called; zero or two-plus children go through `build`\n *   normally. Lets a grammar keep readable layered rules without paying a build\n *   call per collapsing layer \u2014 and without hand-writing\n *   `if (children.length === 1) return children[0]` in every wrapper builder.\n */\nexport type NodeOptions = { collapse?: boolean }\n\n/** A captured child's value form: a leaf unwraps to its string value, else as-is. */\nfunction collapseChild(child: unknown): unknown {\n  return child !== null && typeof child === 'object' && (child as { _tag?: string })._tag === 'leaf'\n    ? (child as { value: unknown }).value\n    : child\n}\n\nexport function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>, opts?: NodeOptions): Combinator<N> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const collapse = opts?.collapse === true\n  const def: Extract<ParserDef, { tag: 'node' }> = collapse\n    ? { tag: 'node', type, parser: combinator, build, collapse: true }\n    : { tag: 'node', type, parser: combinator, build }\n  // Arity-gated elision \u2014 decided once, identically to the compiler (build-arity.ts).\n  // When the build never reads the trivia (4th) arg, disable per-node CST-trivia\n  // capture for the inner scope; when it never reads state (5th), skip the state clone.\n  const capturesTrivia = buildReadsTrivia(def)\n  const clonesState = buildReadsState(def)\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      // Short-circuit the per-node trivia push (scanTrivia gates on captureTrivia)\n      // without touching the global _triviaLog, which is committed independently.\n      if (!capturesTrivia) ctx.captureTrivia = false\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      // collapse: a single captured child IS the value \u2014 skip build.\n      const built: unknown = collapse && children.length === 1\n        ? collapseChild(children[0])\n        : build(\n          children, rawChildren, r.span, triviaLog,\n          clonesState && ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined,\n        )\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 as N, 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", "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", "/**\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 *   x?<lit><[X]*>\u2026         \u2192 a general linear chain of lit/run     (seq)\n *\n * `seq` is the CATEGORY generalization: any chain of literal segments (required\n * or optional `x?`) and char-class runs (positive/negated, `?`/`*`/`+`). It\n * subsumes CSS/Less `-?ident`, `--custom`, `@-?keyword`, `[^\u2026]+`, `::?`, etc.\n * without hardcoding a single byte \u2014 lowered only when a greedy one-pass scan\n * provably equals the engine's backtracking (see `seqIsUnambiguous`).\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\n/**\n * One segment of a `seq` shape. A `seq` is the general category \"a fixed linear\n * chain of literals and char-class runs\" \u2014 no alternation, no groups, no\n * backtracking. It subsumes every CSS/Less token that is \"(optional prefix)?\n * literal* char-run* \u2026\" without hardcoding any particular byte:\n *\n *   lit   \u2014 a run of fixed code points, optionally present (`x?`) or required.\n *   run   \u2014 a char-class run: positive/negated ranges, min 0/1, bounded to one\n *           char (`[x]`, `[x]?`) or unbounded (`[x]*`, `[x]+`).\n *   group \u2014 a non-capturing sub-pattern `(?:\u2026)` (\u00A78f), quantified the same way\n *           as `run` (`min`/`unbounded`). `inner` is any already-recognized\n *           `ScanShape` for the group's body (so a group can itself contain\n *           `seq`/`chars`/`alt`/\u2026 \u2014 including a nested alternation via \u00A78e).\n *           Only used when `groupInnerSafe(inner)` holds (see that function).\n *\n * We only lower a `seq` when greedy left-to-right scanning provably equals the\n * regex engine's backtracking match (see `seqIsUnambiguous`).\n */\nexport type SeqPart =\n  | { part: 'lit'; cps: number[]; optional: boolean }\n  | { part: 'run'; ranges: Array<[number, number]>; negated: boolean; min: 0 | 1; unbounded: boolean }\n  | { part: 'group'; inner: ScanShape; min: 0 | 1; unbounded: boolean }\n\nexport type ScanShape =\n  | { kind: 'chars'; ranges: Array<[number, number]>; minOne: boolean }\n  | { kind: 'ident'; head: Array<[number, number]>; tail: Array<[number, number]> }\n  | { kind: 'until'; open: number[]; stop: Array<[number, number]> }\n  | { kind: 'delimited'; open: number[]; close: number[] }\n  // <q>(?:[^<q>\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with backslash escapes.\n  // `excluded` = the body's negated class (always contains the quote + backslash,\n  // maybe a newline); `escLineTerm` = whether `\\\\` may be followed by a line\n  // terminator (`\\\\[\\s\\S]` \u2192 true, `\\\\.` \u2192 false, since `.` excludes them).\n  | { kind: 'string'; quote: number; excluded: Array<[number, number]>; escLineTerm: boolean }\n  // A linear chain of literal/char-run segments (optional prefixes, literal\n  // openers, negated runs, \u2026) \u2014 the general CSS/Less token category.\n  | { kind: 'seq'; parts: SeqPart[] }\n  // A pure literal matched case-insensitively (`/i`): the general \"ASCII\n  // case-fold literal\" category (CSS `url(`, `@media` keywords under `i`, \u2026).\n  | { kind: 'litFold'; open: number[] }\n  // `<inner>(?!class)` / `<inner>(?=class)` \u2014 a trailing lookahead boundary\n  // check on an already-lowered shape. Zero-width: `end` is `inner`'s end, never\n  // extended. `classNegated` is the bracket's OWN `[^\u2026]` negation (e.g.\n  // `(?![0-9a-fA-F])` vs `(?=[^0-9])`), independent of `negative` (`!` vs `=`).\n  | { kind: 'lookahead'; inner: ScanShape; ranges: Array<[number, number]>; classNegated: boolean; negative: boolean }\n  // `A|B|C` \u2014 top-level alternation (\u00A78e), split outside any `[]`/`()`, each arm\n  // independently lowered. `disjoint` is true iff every pair of arms has\n  // provably non-overlapping first-char sets (`firsts[i]` holds that arm's set,\n  // or `null` if it could start with any char \u2014 an unbounded-optional `chars`\n  // arm, or a non-disjoint mix). When `disjoint`, codegen dispatches straight to\n  // the one matching arm; otherwise it tries arms in order and takes the first\n  // that succeeds \u2014 the same ordered-choice semantics as regex `|` itself (see\n  // the ordered-vs-longest verification in PERF_IDEAS \u00A78e).\n  | { kind: 'alt'; arms: ScanShape[]; disjoint: boolean; firsts: Array<CharSet | null> }\n\n/** Backslash (`\\`) code point \u2014 the escape lead char in string shapes. */\nexport const BACKSLASH = 92\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/**\n * `\\s`'s code-point set per the spec's `WhiteSpace` + `LineTerminator`\n * productions \u2014 TAB/LF/VT/FF/CR, SPACE, NBSP, and the Unicode `Zs` space\n * separators. This set is fixed regardless of the `u` flag (unlike `\\d`/`\\w`,\n * which are ASCII-only without `u` but widen with it), so it's always safe to\n * lower to a fixed range scan.\n */\nexport const SPACE_RANGES: Array<[number, number]> = [\n  [9, 13], [32, 32], [160, 160], [5760, 5760], [8192, 8202],\n  [8232, 8232], [8233, 8233], [8239, 8239], [8287, 8287], [12288, 12288], [65279, 65279],\n]\n\n/**\n * ASCII code-point ranges for the shorthand classes we can lower safely. `\\d`\n * and `\\w` are ASCII-only in the default (non-`u`) engine, so they map to fixed\n * ranges. `\\s` maps to `SPACE_RANGES` \u2014 a fixed set unaffected by the `u` flag.\n */\nfunction shorthandRanges(ch: 'd' | 'w' | 's'): Array<[number, number]> {\n  if (ch === 'd') return [[48, 57]]\n  if (ch === 's') return SPACE_RANGES\n  return [[48, 57], [65, 90], [97, 122], [95, 95]]\n}\n\ntype ClassAtom = { cp: number } | { set: Array<[number, number]> }\n\n/**\n * Parse a regex char-class body (chars between `[` and `]`) to code-point ranges.\n * `\\d`/`\\w` expand to their ASCII ranges; other letter escapes (`\\s`, `\\D`,\n * `\\W`, `\\S`, `\\b`, \u2026) return null rather than being mis-read as literal letters.\n */\nfunction readUnicodeEscape(body: string, i: number): { cp: number; next: number } | null {\n  if (body[i] !== '\\\\' || body[i + 1] !== 'u') return null\n  const hex = body.slice(i + 2, i + 6)\n  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null\n  return { cp: Number.parseInt(hex, 16), next: i + 6 }\n}\n\nexport function parseClassRanges(body: string): Array<[number, number]> | null {\n  const ranges: Array<[number, number]> = []\n  let i = 0\n  const readAtom = (): ClassAtom | null => {\n    const ch = body[i]\n    if (ch === undefined) return null\n    if (ch === '\\\\') {\n      const uni = readUnicodeEscape(body, i)\n      if (uni) {\n        i = uni.next\n        return { cp: uni.cp }\n      }\n      const e = body[i + 1]\n      if (e === undefined) return null\n      i += 2\n      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e]! }\n      if (e === 'd' || e === 'w' || e === 's') return { set: shorthandRanges(e) }\n      // Any other letter escape is a class we can't safely lower (\\D, \\W, \\S, \u2026).\n      if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      return { cp: e.codePointAt(0)! }\n    }\n    i += ch.length\n    return { cp: ch.codePointAt(0)! }\n  }\n  while (i < body.length) {\n    const lo = readAtom()\n    if (lo === null) return null\n    if ('set' in lo) {\n      ranges.push(...lo.set)\n      continue\n    }\n    if (body[i] === '-' && body[i + 1] !== undefined && body[i + 1] !== ']') {\n      i += 1\n      const hi = readAtom()\n      if (hi === null || 'set' in hi) return null\n      ranges.push([lo.cp, hi.cp])\n    } else {\n      ranges.push([lo.cp, lo.cp])\n    }\n  }\n  return ranges.length ? ranges : null\n}\n\n/** A single class token (`[...]` or `\\d`/`\\w`) to ranges, or null. Rejects negation. */\nfunction classToRanges(cls: string): Array<[number, number]> | null {\n  if (cls === '\\\\d') return shorthandRanges('d')\n  if (cls === '\\\\w') return shorthandRanges('w')\n  if (cls === '\\\\s') return shorthandRanges('s')\n  const body = cls.slice(1, -1)\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\n}\n\n/** ASCII case-insensitive letter check for `i`-flag literal lowering. */\nconst foldEq = (cVar: string, cp: number): string => {\n  if (cp >= 65 && cp <= 90) return `(${cVar} === ${cp} || ${cVar} === ${cp + 32})`\n  if (cp >= 97 && cp <= 122) return `(${cVar} === ${cp} || ${cVar} === ${cp - 32})`\n  return `${cVar} === ${cp}`\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 a quote-delimited string with backslash escapes:\n *   <q>(?:[^\u2026]|\\\\.)*<q>  or  <q>(?:\\\\.|[^\u2026])*<q>   (`?:` optional)\n * where the negated body class contains the quote and the backslash, and the\n * escape body is `.` (no line terminators) or `[\\s\\S]` (any char). Returns null\n * for anything else so the caller falls back to `regex.exec`.\n */\nfunction parseStringShape(source: string): ScanShape | null {\n  const q = source[0]\n  if (q === undefined || q === '\\\\' || META.has(q)) return null\n  if (source.length < 3 || source[source.length - 1] !== q) return null\n  const inner = source.slice(1, -1)\n  const CLS = String.raw`\\[\\^((?:\\\\.|[^\\]])+)\\]`\n  const ESC = String.raw`\\\\\\\\(\\.|\\[\\\\s\\\\S\\]|\\[\\\\S\\\\s\\])`\n  // Two arm orders; `?:` optional. Capture groups differ, so read both out.\n  let body: string | undefined\n  let esc: string | undefined\n  let m = new RegExp(`^\\\\((?:\\\\?:)?${CLS}\\\\|${ESC}\\\\)\\\\*$`).exec(inner)\n  if (m) { body = m[1]; esc = m[2] }\n  else {\n    m = new RegExp(`^\\\\((?:\\\\?:)?${ESC}\\\\|${CLS}\\\\)\\\\*$`).exec(inner)\n    if (m) { esc = m[1]; body = m[2] }\n  }\n  if (body === undefined || esc === undefined) return null\n  const excluded = parseClassRanges(body)\n  if (!excluded) return null\n  const qcp = q.codePointAt(0)!\n  const inSet = (cp: number) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi)\n  if (!inSet(qcp) || !inSet(BACKSLASH)) return null\n  return { kind: 'string', quote: qcp, excluded, escLineTerm: esc !== '.' }\n}\n\n/**\n * Parse a regex source into a linear chain of literal / char-run segments, or\n * null if it uses any construct outside that category (alternation, groups,\n * `.`, `{n,m}`, lookaround, unknown escapes). This is the STRUCTURAL recognizer\n * for the `seq` shape \u2014 it encodes categories (optional prefix, literal opener,\n * negated run, \u2026), never any specific byte value.\n */\nfunction parseSeqParts(source: string): SeqPart[] | null {\n  const parts: SeqPart[] = []\n  let lit: number[] = []\n  const flush = () => {\n    if (lit.length) { parts.push({ part: 'lit', cps: lit, optional: false }); lit = [] }\n  }\n  const runFrom = (ranges: Array<[number, number]>, negated: boolean, q: string | undefined) => {\n    if (q === '+') { parts.push({ part: 'run', ranges, negated, min: 1, unbounded: true }); return 1 }\n    if (q === '*') { parts.push({ part: 'run', ranges, negated, min: 0, unbounded: true }); return 1 }\n    if (q === '?') { parts.push({ part: 'run', ranges, negated, min: 0, unbounded: false }); return 1 }\n    parts.push({ part: 'run', ranges, negated, min: 1, unbounded: false })\n    return 0\n  }\n  let i = 0\n  while (i < source.length) {\n    const ch = source[i]!\n    if (ch === '[') {\n      // Read a char class, honoring `\\]`.\n      let k = i + 1\n      const neg = source[k] === '^'\n      if (neg) k++\n      let body = ''\n      while (k < source.length && source[k] !== ']') {\n        if (source[k] === '\\\\') { body += source[k]! + (source[k + 1] ?? ''); k += 2 }\n        else { body += source[k]!; k++ }\n      }\n      if (source[k] !== ']') return null\n      const ranges = parseClassRanges(body)\n      if (!ranges) return null\n      flush()\n      i = k + 1\n      i += runFrom(ranges, neg, source[i])\n      continue\n    }\n    if (ch === '\\\\') {\n      const e = source[i + 1]\n      if (e === 'd' || e === 'w' || e === 's') {\n        flush()\n        i += 2\n        i += runFrom(shorthandRanges(e), false, source[i])\n        continue\n      }\n      // Escaped literal code point (incl. `\\uXXXX`, `\\t`, `\\(`, \u2026).\n      const uni = readUnicodeEscape(source, i)\n      let cp: number\n      if (uni) { cp = uni.cp; i = uni.next }\n      else if (e === undefined) return null\n      else if (e in CLASS_ESCAPES) { cp = CLASS_ESCAPES[e]!; i += 2 }\n      else if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      else { cp = e.codePointAt(0)!; i += 2 }\n      if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n      else lit.push(cp)\n      continue\n    }\n    if (ch === '(') {\n      // Only a non-capturing group `(?:\u2026)` is modeled (\u00A78f) \u2014 a bare capturing\n      // group, or a lookaround appearing mid-pattern (a TRAILING one is peeled\n      // off separately by `stripTrailingLookahead` before we ever get here), is\n      // declined outright rather than risk misreading it.\n      if (source[i + 1] !== '?' || source[i + 2] !== ':') return null\n      let k = i + 3\n      let depth = 1\n      while (k < source.length && depth > 0) {\n        const c2 = source[k]\n        if (c2 === '\\\\') { k += 2; continue }\n        if (c2 === '[') {\n          let j = k + 1\n          if (source[j] === '^') j++\n          while (j < source.length && source[j] !== ']') {\n            if (source[j] === '\\\\') j += 2\n            else j++\n          }\n          if (source[j] !== ']') return null\n          k = j + 1\n          continue\n        }\n        if (c2 === '(') depth++\n        else if (c2 === ')') depth--\n        k++\n      }\n      if (depth !== 0) return null\n      const body = source.slice(i + 3, k - 1)\n      const inner = parseScanShape(body)\n      if (!inner || !groupInnerSafe(inner)) return null\n      const q = source[k]\n      // `{n,m}` on a group is a \u00A78c/\u00A78f combination not modeled \u2014 decline.\n      if (q === '{') return null\n      flush()\n      if (q === '+') {\n        if (shapeCanBeEmpty(inner)) return null // would loop forever \u2014 decline\n        parts.push({ part: 'group', inner, min: 1, unbounded: true })\n        i = k + 1\n      } else if (q === '*') {\n        if (shapeCanBeEmpty(inner)) return null\n        parts.push({ part: 'group', inner, min: 0, unbounded: true })\n        i = k + 1\n      } else if (q === '?') {\n        parts.push({ part: 'group', inner, min: 0, unbounded: false })\n        i = k + 1\n      } else {\n        parts.push({ part: 'group', inner, min: 1, unbounded: false })\n        i = k\n      }\n      continue\n    }\n    // A bare metachar (`|`, `.`, `{`, stray `*`/`+`/`?`, \u2026) is outside the\n    // linear-chain category \u2014 bail to the RegExp fallback.\n    if (META.has(ch)) return null\n    const cp = ch.codePointAt(0)!\n    i += ch.length\n    if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n    else lit.push(cp)\n  }\n  flush()\n  return parts.length ? parts : null\n}\n\n/**\n * Only lower a `seq` when greedy left-to-right scanning matches EXACTLY what the\n * backtracking regex engine would. The dangerous cases are (a) an optional part\n * that could also be consumed by what follows, and (b) an unbounded/repeated\n * part whose accepted class overlaps what follows \u2014 both let the engine\n * backtrack to a different boundary than a one-pass scan. We also require at\n * least one mandatory segment (so the token can't match zero-width).\n *\n * A skippable/repeatable part `p` at index `k` is checked against\n * `seqFirstAccept(parts.slice(k + 1))` \u2014 the accept-set of EVERYTHING that\n * could start at the very next position, unioned through any further chain of\n * optionals up to the next mandatory part (the exact same computation\n * `seqFirstAccept` already does for a seq's OWN leading accept-set). This\n * subsumes the simpler \"check only the immediate neighbor\" rule as the\n * one-part-following case, while also correctly handling a CHAIN of several\n * consecutive optional parts (e.g. two independent optional groups in a row,\n * `(?:\\.\\d+)?(?:[eE][+-]?\\d+)?` \u2014 JSON/GraphQL's number tail, \u00A78f): each is\n * safe precisely when disjoint from everything that could follow it, however\n * many further optionals that spans. An empty tail (`p` is the last part)\n * naturally resolves to a trivially-disjoint empty set \u2014 nothing to check.\n *\n * Uniform across `lit`/`run`/`group`: each part's own \"first char it could\n * start with\" (`partFirstAccept`) is compared via `firstSetsDisjoint` \u2014 the\n * same subset/disjoint math used everywhere else in this file (\u00A78b's\n * lookahead guard, \u00A78e's alt-dispatch guard).\n */\nfunction seqIsUnambiguous(parts: SeqPart[]): boolean {\n  let hasMandatory = false\n  for (let k = 0; k < parts.length; k++) {\n    const p = parts[k]!\n    const mandatory = p.part === 'lit' ? !p.optional : p.min === 1\n    if (mandatory) hasMandatory = true\n    const skippableSingle =\n      (p.part === 'lit' && p.optional) || (p.part !== 'lit' && !p.unbounded && p.min === 0)\n    const isUnboundedRepeat = p.part !== 'lit' && p.unbounded\n    if (skippableSingle || isUnboundedRepeat) {\n      const rest = seqFirstAccept(parts.slice(k + 1))\n      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false\n    }\n  }\n  return hasMandatory\n}\n\nfunction rangesOverlap(a: Array<[number, number]>, b: Array<[number, number]>): boolean {\n  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi))\n}\n\n/** Is every range in `sub` fully contained in some range of `sup`? */\nfunction rangesSubset(sub: Array<[number, number]>, sup: Array<[number, number]>): boolean {\n  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2))\n}\n\n/**\n * A `(?!X)`/`(?=X)` operand: a char class (`[...]`, incl. `[^...]`), a\n * shorthand class (`\\d`/`\\w`/`\\s`), or a single literal/escaped char \u2014 never a\n * sub-pattern (no alternation, no nested groups). Returns the ranges to test\n * membership against, and whether the bracket itself was negated (`[^...]`) \u2014\n * independent of the lookahead's own `!`/`=` polarity.\n */\nfunction parseClassOperand(body: string): { ranges: Array<[number, number]>; negated: boolean } | null {\n  if (body === '\\\\d' || body === '\\\\w' || body === '\\\\s') {\n    return { ranges: shorthandRanges(body[1] as 'd' | 'w' | 's'), negated: false }\n  }\n  if (body.length >= 2 && body[0] === '[' && body[body.length - 1] === ']') {\n    let inner = body.slice(1, -1)\n    const negated = inner.startsWith('^')\n    if (negated) inner = inner.slice(1)\n    const ranges = parseClassRanges(inner)\n    return ranges ? { ranges, negated } : null\n  }\n  const cps = literalCodePoints(body)\n  if (cps && cps.length === 1) return { ranges: [[cps[0]!, cps[0]!]], negated: false }\n  return null\n}\n\ntype TrailingLookahead = {\n  base: string\n  ranges: Array<[number, number]>\n  classNegated: boolean\n  negative: boolean\n}\n\ntype CharSet = { ranges: Array<[number, number]>; negated: boolean }\n\n/** Is char-set `t` fully contained in char-set `u`? Handles all 4 sign combos. */\nfunction classSubset(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges) // t \u2286 \u00ACu \u27FA t \u2229 u = \u2205\n  if (t.negated && !u.negated) return false // \u00ACt \u2286 u is never true for finite ranges u\n  return rangesSubset(u.ranges, t.ranges) // \u00ACt \u2286 \u00ACu \u27FA u \u2286 t\n}\n\n/** Are char-sets `t` and `u` disjoint (no overlap)? Handles all 4 sign combos. */\nfunction classDisjoint(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges) // t \u2229 \u00ACu = \u2205 \u27FA t \u2286 u\n  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges) // symmetric\n  return false // \u00ACt \u2229 \u00ACu = \u2205 would require t \u222A u = every code point \u2014 can't prove with finite ranges\n}\n\n/** `classDisjoint`, `'any'`-aware: an empty-capable part's first-set degrades\n * to `'any'` (see `shapeFirstAccept`), and `'any'` is never disjoint from\n * anything (it could start with literally any char, including whatever the\n * other side accepts). */\nfunction firstSetsDisjoint(a: CharSet | 'any', b: CharSet | 'any'): boolean {\n  if (a === 'any' || b === 'any') return false\n  return classDisjoint(a, b)\n}\n\n/**\n * The char-class a backtracking engine could expose by shrinking `shape`'s\n * OWN trailing quantifier by one position \u2014 i.e. the \"wiggle room\" a trailing\n * lookahead could interact with. Returns `null` when `shape`'s matched length\n * is fully fixed once it succeeds (no quantifier to shrink), which makes\n * wrapping it in a lookahead unconditionally safe. Returns `'unsupported'` for\n * shape kinds whose backtracking semantics aren't modeled here (declines the\n * lookahead lowering rather than risking an unproven guard).\n *\n * Only the LAST quantifier matters: `seqIsUnambiguous` already proves every\n * EARLIER part of a `seq` has exactly one valid parse (no alternate length),\n * so the sole remaining freedom a backtracking engine has \u2014 once we attach an\n * external trailing lookahead \u2014 is in whatever quantifier sits at the very end.\n */\nfunction trailingBacktrackClass(shape: ScanShape): CharSet | null | 'unsupported' {\n  if (shape.kind === 'chars') return { ranges: shape.ranges, negated: false }\n  if (shape.kind === 'ident') return { ranges: shape.tail, negated: false }\n  if (shape.kind === 'litFold') return null // fixed-length literal \u2014 no quantifier at all\n  if (shape.kind === 'seq') {\n    const last = shape.parts[shape.parts.length - 1]!\n    if (last.part === 'lit') return null // fixed literal tail \u2014 no wiggle room\n    if (last.part === 'run') {\n      // unbounded (`+`/`*`) or optional-bounded (`[x]?`) both have a\n      // 1-position choice a backtracker could make; `[x]` (min 1, bounded) is\n      // a single required char \u2014 no choice, hence no risk.\n      if (last.unbounded || last.min === 0) return { ranges: last.ranges, negated: last.negated }\n      return null\n    }\n    // A trailing `group` (\u00A78f): its own inner shape may have wiggle room\n    // (`innerWiggle`, e.g. the group's body itself ends in an unbounded run),\n    // AND \u2014 if the group is optional/repeated \u2014 dropping the group's presence\n    // entirely exposes its own first-char set (`dropExposed`) as the new\n    // boundary char. Both are real backtrack moves; a lookahead must be safe\n    // against whichever one could actually happen.\n    const innerWiggle = trailingBacktrackClass(last.inner)\n    if (innerWiggle === 'unsupported') return 'unsupported'\n    const requiredOnce = !last.unbounded && last.min === 1\n    if (requiredOnce) return innerWiggle // no \"drop it\" move possible \u2014 only inner's own wiggle matters\n    const dropExposed = shapeFirstAccept(last.inner)\n    if (dropExposed === 'any') return 'unsupported'\n    if (innerWiggle === null) return dropExposed\n    const unioned = unionCharSets([innerWiggle, dropExposed])\n    return unioned === 'any' ? 'unsupported' : unioned\n  }\n  if (shape.kind === 'alt') {\n    // Arm-switching hazard (see `groupInnerSafe`) applies here too: a\n    // non-disjoint alt can't be trusted to expose the right wiggle class,\n    // since which arm ultimately \"wins\" could itself change under backtrack.\n    // A disjoint alt has no such hazard \u2014 exactly one arm is ever reachable\n    // from a given starting char, so the union of every arm's OWN wiggle\n    // covers whichever one is actually taken.\n    if (!shape.disjoint) return 'unsupported'\n    const classes = shape.arms.map(trailingBacktrackClass)\n    if (classes.some(c => c === 'unsupported')) return 'unsupported'\n    const concrete = classes.filter((c): c is CharSet => c !== null)\n    if (concrete.length === 0) return null\n    const unioned = unionCharSets(concrete)\n    return unioned === 'any' ? 'unsupported' : unioned\n  }\n  // `until`/`delimited`/`string`/nested `lookahead` \u2014 not modeled; decline.\n  return 'unsupported'\n}\n\n/**\n * Is it safe to lower `inner(?!ranges)` / `inner(?=ranges)` to a one-shot\n * post-match check (vs. requiring real backtracking)? See PERF_IDEAS \u00A78b.\n */\nfunction lookaheadUnambiguous(inner: ScanShape, operand: CharSet, negative: boolean): boolean {\n  const tail = trailingBacktrackClass(inner)\n  if (tail === 'unsupported') return false\n  if (tail === null) return true // inner's length is fixed \u2014 no backtracking possible\n  // Negative `(?!op)`: safe iff every char the tail could expose is ALSO\n  // excluded by `op` (so shrinking never turns a failure into a pass).\n  // Positive `(?=op)`: safe iff the tail is disjoint from `op` (so shrinking\n  // could never expose a char that suddenly satisfies `op`).\n  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand)\n}\n\n/**\n * Strip a trailing `(?!class)` / `(?=class)` boundary assertion, if present.\n * Only a TRAILING lookahead with a char-class/single-char operand is\n * recognized \u2014 no sub-patterns, no nested groups. Anything else containing an\n * unescaped `(` is left to the other recognizers, which reject it as a\n * metachar (`META`) and fall back to `RegExp.exec`, so a false read here can\n * only fail to lower, never mis-lower.\n */\nfunction stripTrailingLookahead(source: string): TrailingLookahead | null {\n  if (!source.endsWith(')')) return null\n  for (const negative of [true, false] as const) {\n    const lead = negative ? '(?!' : '(?='\n    const idx = source.lastIndexOf(lead)\n    if (idx === -1) continue\n    const body = source.slice(idx + lead.length, -1)\n    const operand = body.length ? parseClassOperand(body) : null\n    if (!operand) continue\n    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative }\n  }\n  return null\n}\n\n/**\n * Strip ONE redundant outer `(?:\u2026)` wrapper, if it spans the ENTIRE source\n * (nothing before it, nothing \u2014 not even a quantifier \u2014 after its matching\n * close). A non-capturing group with no trailing quantifier is semantically\n * identical to its bare contents, so this is always safe to unwrap; it's what\n * lets `(?:a|b|c)` (a whole-token alternation written as idiomatic regex\n * style, e.g. CSS `basicSel`) reach the top-level `|` split below. Bails\n * (leaves `source` untouched) on anything that isn't a clean whole-string\n * wrap: unbalanced parens, or a group that closes before the string ends\n * (which would mean a quantifier or trailing content follows it).\n */\nfunction unwrapOuterGroup(source: string): string {\n  while (source.startsWith('(?:')) {\n    let depth = 1\n    let i = 3\n    let ok = true\n    while (i < source.length && depth > 0) {\n      const ch = source[i]\n      if (ch === '\\\\') { i += 2; continue }\n      if (ch === '[') {\n        let j = i + 1\n        if (source[j] === '^') j++\n        while (j < source.length && source[j] !== ']') {\n          if (source[j] === '\\\\') j += 2\n          else j++\n        }\n        if (source[j] !== ']') { ok = false; break }\n        i = j + 1\n        continue\n      }\n      if (ch === '(') depth++\n      else if (ch === ')') depth--\n      i++\n    }\n    if (!ok || depth !== 0 || i !== source.length) break\n    source = source.slice(3, -1)\n  }\n  return source\n}\n\n/**\n * Split a regex source on top-level `|` \u2014 i.e. `|` outside any `[]` bracket\n * class and outside any `(...)` group (parens still count toward depth even\n * though we don't otherwise understand groups; a `|` nested in one is never a\n * split point). Returns null if there's no top-level `|` at all, if brackets/\n * parens are unbalanced, or if any resulting alternative is empty (a\n * zero-width arm \u2014 an unmodeled edge case, decline rather than mis-lower).\n * One redundant whole-string `(?:\u2026)` wrapper is stripped first (see\n * `unwrapOuterGroup`) so `(?:a|b)` splits the same as bare `a|b`.\n */\nfunction splitTopLevelAlternation(source: string): string[] | null {\n  const body = unwrapOuterGroup(source)\n  const parts: string[] = []\n  let depth = 0\n  let last = 0\n  let i = 0\n  while (i < body.length) {\n    const ch = body[i]\n    if (ch === '\\\\') { i += 2; continue }\n    if (ch === '[') {\n      let j = i + 1\n      if (body[j] === '^') j++\n      while (j < body.length && body[j] !== ']') {\n        if (body[j] === '\\\\') j += 2\n        else j++\n      }\n      if (body[j] !== ']') return null\n      i = j + 1\n      continue\n    }\n    if (ch === '(') { depth++; i++; continue }\n    if (ch === ')') { depth--; if (depth < 0) return null; i++; continue }\n    if (ch === '|' && depth === 0) {\n      parts.push(body.slice(last, i))\n      last = i + 1\n      i++\n      continue\n    }\n    i++\n  }\n  if (depth !== 0) return null\n  parts.push(body.slice(last))\n  if (parts.length < 2 || parts.some(p => p.length === 0)) return null\n  return parts\n}\n\n/** Can `shape` match the empty string? Only an unbounded `chars` run with no\n * `+` (`[x]*`) can \u2014 every other shape requires at least one fixed/mandatory\n * char (`seq` always has \u22651 mandatory part per `seqIsUnambiguous`; `ident`/\n * `until`/`delimited`/`string`/`litFold` all require a fixed opening char). A\n * `lookahead`/`alt` defer to what they wrap. */\nfunction shapeCanBeEmpty(shape: ScanShape): boolean {\n  if (shape.kind === 'chars') return !shape.minOne\n  if (shape.kind === 'lookahead') return shapeCanBeEmpty(shape.inner)\n  if (shape.kind === 'alt') return shape.arms.some(shapeCanBeEmpty)\n  return false\n}\n\n/** Exact union of char-sets when it's computable, else `'any'` (conservative:\n * forces ordered dispatch rather than guessing at a mixed-polarity union, or\n * when any input is already `'any'`). A single concrete-set list is returned\n * as-is (including if negated) \u2014 the ambiguity is only in combining \u22652 sets\n * of differing polarity. */\nfunction unionCharSets(sets: Array<CharSet | 'any'>): CharSet | 'any' {\n  if (sets.some(s => s === 'any')) return 'any'\n  const concrete = sets as CharSet[]\n  if (concrete.length === 1) return concrete[0]!\n  if (concrete.some(s => s.negated)) return 'any'\n  return { ranges: concrete.flatMap(s => s.ranges), negated: false }\n}\n\n/** A single seq part's own first-char set, ignoring whether it's skippable.\n * A `group` part delegates to its inner shape's own first-set (\u00A78f) \u2014\n * possibly `'any'` if the inner shape can match empty or is a non-disjoint\n * `alt` (see `shapeFirstAccept`). */\nfunction partFirstAccept(part: SeqPart): CharSet | 'any' {\n  if (part.part === 'lit') return { ranges: [[part.cps[0]!, part.cps[0]!]], negated: false }\n  if (part.part === 'run') return { ranges: part.ranges, negated: part.negated }\n  return shapeFirstAccept(part.inner)\n}\n\n/** The char-set a `seq` can start with: union of each leading skippable part's\n * own set up to and including the first mandatory part (after which later\n * parts can no longer be what the very first input char matches). */\nfunction seqFirstAccept(parts: SeqPart[]): CharSet | 'any' {\n  const sets: Array<CharSet | 'any'> = []\n  for (const p of parts) {\n    const mandatory = p.part === 'lit' ? !p.optional : p.min === 1\n    sets.push(partFirstAccept(p))\n    if (mandatory) break\n  }\n  return unionCharSets(sets)\n}\n\n/**\n * Is `inner` safe to use as a group's body (\u00A78f)? `chars`/`ident`/`seq`/\n * `litFold` are always safe: each is only ever constructed after proving (via\n * `seqIsUnambiguous` or equivalent) that greedy resolution is the UNIQUE valid\n * match at a given position \u2014 there is no alternate length for a backtracker\n * to reconsider, so treating the group as an atomic, resolve-once unit is\n * sound regardless of what follows it. A `lookahead` defers to what it wraps\n * (zero-width, adds no new choice). An `alt` is safe ONLY when `disjoint`:\n * a NON-disjoint alt (`(?:a|ab)`) genuinely can need real backtracking into a\n * DIFFERENT arm if something after the group fails (verified: `/^(?:a|ab)c/`\n * matches \"abc\" via the SECOND arm, only because the first arm's match left\n * \"c\" unsatisfied) \u2014 our ordered-dispatch codegen resolves once and never\n * reconsiders, so that case must decline. `until`/`delimited`/`string` are\n * declined outright, same conservative call as `trailingBacktrackClass`.\n */\nfunction groupInnerSafe(shape: ScanShape): boolean {\n  if (shape.kind === 'chars' || shape.kind === 'ident' || shape.kind === 'seq' || shape.kind === 'litFold') return true\n  if (shape.kind === 'lookahead') return groupInnerSafe(shape.inner)\n  if (shape.kind === 'alt') return shape.disjoint\n  return false\n}\n\n/**\n * The set of first chars a NON-EMPTY match of `shape` could start with, or\n * `'any'` if that can't be pinned down to a single char-set (used to decide\n * whether `alt` arms have disjoint first-sets). A shape that can match empty\n * degrades to `'any'`: since it could succeed with zero chars regardless of\n * what follows, it would \"accept\" any first char by never actually needing one\n * \u2014 treating that as disjoint from anything else would be unsound.\n */\nfunction shapeFirstAccept(shape: ScanShape): CharSet | 'any' {\n  if (shapeCanBeEmpty(shape)) return 'any'\n  switch (shape.kind) {\n    case 'chars': return { ranges: shape.ranges, negated: false }\n    case 'ident': return { ranges: shape.head, negated: false }\n    case 'until': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'delimited': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'string': return { ranges: [[shape.quote, shape.quote]], negated: false }\n    case 'litFold': {\n      const cp = shape.open[0]!\n      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false }\n      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false }\n      return { ranges: [[cp, cp]], negated: false }\n    }\n    case 'seq': return seqFirstAccept(shape.parts)\n    case 'lookahead': return shapeFirstAccept(shape.inner) // zero-width \u2014 doesn't change first-char acceptance\n    case 'alt': {\n      if (!shape.disjoint) return 'any'\n      const sets = shape.firsts.filter((f): f is CharSet => f !== null)\n      return sets.length === shape.arms.length ? unionCharSets(sets) : 'any'\n    }\n  }\n}\n\n/** True iff every pair of `sets` is provably disjoint; `'any'` is disjoint from nothing. */\nfunction allPairsDisjoint(sets: Array<CharSet | 'any'>): boolean {\n  for (let i = 0; i < sets.length; i++) {\n    const a = sets[i]!\n    if (a === 'any') return false\n    for (let j = i + 1; j < sets.length; j++) {\n      const b = sets[j]!\n      if (b === 'any' || !classDisjoint(a, b)) return false\n    }\n  }\n  return true\n}\n\n/**\n * Recognize top-level alternation `A|B|C` (\u00A78e): split on `|` outside any\n * `[]`/`()`, lower each arm independently (an arm may itself be a `seq`,\n * `chars`, `lookahead`, \u2026, or even nested alternation via one redundant\n * `(?:\u2026)` wrapper \u2014 see `unwrapOuterGroup`). Declines (null) unless EVERY arm\n * independently lowers \u2014 a single unsupported arm (e.g. one with a nested\n * capturing/non-capturing group, \u00A78f) falls the whole alternation back to\n * `RegExp.exec` rather than partially lowering.\n */\nfunction parseAlternation(source: string): ScanShape | null {\n  const parts = splitTopLevelAlternation(source)\n  if (!parts) return null\n  const arms: ScanShape[] = []\n  for (const p of parts) {\n    const arm = parseScanShape(p)\n    if (!arm) return null\n    arms.push(arm)\n  }\n  const firstSets = arms.map(shapeFirstAccept)\n  const disjoint = allPairsDisjoint(firstSets)\n  return { kind: 'alt', arms, disjoint, firsts: firstSets.map(f => (f === 'any' ? null : f)) }\n}\n\n/**\n * Recognize one scannable arm from its regex source, or null if it isn't one of\n * the structural shapes. Top-level alternation (\u00A78e) is tried FIRST \u2014 `|` has\n * the lowest precedence in regex, so splitting on it happens before anything\n * else, with each arm then recursively re-entering this same function (so an\n * arm's own trailing lookahead, or its own nested `(?:\u2026)`-wrapped alternation,\n * is still recognized). Failing that: char-class run, ident, string, then\n * open-until-terminator, delimited, and finally the general linear `seq` chain.\n * A trailing `(?!class)`/`(?=class)` is peeled off next (\u00A78b) and re-wraps\n * whatever shape the remaining base recognizes as.\n */\nexport function parseScanShape(source: string): ScanShape | null {\n  const alt = parseAlternation(source)\n  if (alt) return alt\n  const la = stripTrailingLookahead(source)\n  if (la) {\n    const inner = parseScanShapeCore(la.base)\n    if (!inner) return null\n    const operand: CharSet = { ranges: la.ranges, negated: la.classNegated }\n    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null\n    return { kind: 'lookahead', inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative }\n  }\n  return parseScanShapeCore(source)\n}\n\nfunction parseScanShapeCore(source: string): ScanShape | null {\n  // [X]+ / [X]* \u2014 a positive char-class run. A negated `[^X]+`/`[^X]*` is left to\n  // the general `seq` path (which lowers `[^X]+` and declines zero-width `[^X]*`).\n  let m = /^\\[((?:\\\\.|[^\\]])+)\\]([+*])$/.exec(source)\n  if (m && !m[1]!.startsWith('^')) {\n    const ranges = parseClassRanges(m[1]!)\n    return ranges ? { kind: 'chars', ranges, minOne: m[2] === '+' } : null\n  }\n  // \\d+ / \\w+ / \\s+ / \\d* / \\w* / \\s* \u2014 a bare shorthand-class run.\n  m = /^\\\\([dws])([+*])$/.exec(source)\n  if (m) {\n    return { kind: 'chars', ranges: shorthandRanges(m[1] as 'd' | 'w' | 's'), minOne: m[2] === '+' }\n  }\n  // <head><tail>* \u2014 identifier run: one head char, then a run of tail chars.\n  m = /^(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])\\*$/.exec(source)\n  if (m) {\n    const head = classToRanges(m[1]!)\n    const tail = classToRanges(m[2]!)\n    if (head && tail) return { kind: 'ident', head, tail }\n  }\n  // <q>(?:[^q\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with escapes.\n  const str = parseStringShape(source)\n  if (str) return str\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  }\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  // General category: a linear chain of literals + char runs (optional prefixes,\n  // literal openers, negated runs), lowered only when unambiguously greedy.\n  const parts = parseSeqParts(source)\n  if (parts && seqIsUnambiguous(parts)) return { kind: 'seq', parts }\n  return null\n}\n\n/**\n * Flag-aware wrapper around `parseScanShape`. Lowering to a raw code-point scan\n * assumes default regex semantics, so any flag that changes matching (`i` case\n * folding, `u` surrogate handling, `m`/`s` anchor/dot behavior) disables it.\n * `g`/`y` are stickiness-only and safe.\n */\nexport function scanShapeFromRegex(source: string, flags: string): ScanShape | null {\n  if (/[msu]/.test(flags)) return null\n  if (/i/.test(flags)) {\n    const open = literalCodePoints(source)\n    return open ? { kind: 'litFold', open } : null\n  }\n  return parseScanShape(source)\n}\n\nexport const 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. */\nexport const 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/** Line-terminator code points `.` does not match (`\\n \\r \\u2028 \\u2029`). */\nexport const LINE_TERMINATORS = [10, 13, 8232, 8233] as const\n\n/** The body-stop chars that abort a string match (excluded set minus quote/backslash). */\nexport function stringHardStop(\n  shape: Extract<ScanShape, { kind: 'string' }>,\n): Array<[number, number]> {\n  return shape.excluded.filter(\n    ([lo, hi]) => !(lo === hi && (lo === shape.quote || lo === BACKSLASH)),\n  )\n}\n\n/** Mints a fresh, unique local variable name (`prefix` + counter). */\nexport type Mint = (prefix?: string) => string\n\n/**\n * The SINGLE source of truth for how a scannable shape matches at `start`. Both\n * the terminal emitter and the trivia scan loop consume this, so no context can\n * silently reinterpret an incomplete match (e.g. an unterminated string):\n *\n *   - `setup`   statements (indented by `ind`) that compute the match.\n *   - `ok`      a boolean expr: did a token match at `start`? (zero-width for\n *               `chars*` counts as a match \u2014 terminals allow it.)\n *   - `end`     the position AFTER the token. **Invariant:** `end === start`\n *               whenever there is no progress (match failed or matched empty),\n *               so the trivia loop can gate purely on `end > start`.\n *\n * `firstChar`, when supplied, is an expression already equal to\n * `charCodeAt(start)` (the trivia loop reads it once and shares it).\n */\nexport type ShapeMatch = { setup: string[]; ok: string; end: string }\n\nconst codeAt = (start: string, firstChar?: string): string =>\n  firstChar ?? `input.charCodeAt(${start})`\n\nexport function emitShapeMatch(\n  shape: ScanShape,\n  start: string,\n  mint: Mint,\n  ind: string,\n  firstChar?: string,\n): ShapeMatch {\n  if (shape.kind === 'lookahead') {\n    const inner = emitShapeMatch(shape.inner, start, mint, ind, firstChar)\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    // `charInClass` folds the operand's OWN `[^\u2026]` negation in; `guardFails`\n    // then applies the lookahead's `!`/`=` polarity on top. Zero-width: `end`\n    // is always `inner.end` (on success) or `start` (on failure) \u2014 never past\n    // where `inner` itself stopped.\n    const rawIn = classCond(`input.charCodeAt(${inner.end})`, shape.ranges)\n    const charInClass = shape.classNegated ? `!(${rawIn})` : `(${rawIn})`\n    const hasMatchingChar = `${inner.end} < input.length && ${charInClass}`\n    const guardFails = shape.negative ? hasMatchingChar : `!(${hasMatchingChar})`\n    return {\n      setup: [\n        ...inner.setup,\n        `${ind}let ${okV} = ${inner.ok}`,\n        `${ind}let ${endV} = ${inner.end}`,\n        `${ind}if (${okV} && (${guardFails})) { ${okV} = false; ${endV} = ${start} }`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'alt') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const lines: string[] = [`${ind}let ${okV} = false`, `${ind}let ${endV} = ${start}`]\n    if (shape.disjoint) {\n      // Mutually exclusive first-sets: dispatch straight to the one matching\n      // arm, no ordering/backtracking concerns (\u00A77b-style disjoint dispatch).\n      const c0 = codeAt(start, firstChar)\n      shape.arms.forEach((arm, k) => {\n        const fs = shape.firsts[k]! // non-null whenever `disjoint` is true\n        const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`\n        const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n        lines.push(`${ind}${k === 0 ? 'if' : 'else if'} (${start} < input.length && ${cond}) {`)\n        lines.push(...m.setup)\n        lines.push(`${ind}  ${okV} = ${m.ok}`)\n        lines.push(`${ind}  ${endV} = ${m.ok} ? ${m.end} : ${start}`)\n        lines.push(`${ind}}`)\n      })\n    } else {\n      // Overlapping first-sets: ordered choice \u2014 try each arm in turn and take\n      // the first that succeeds. This is exactly regex `|`'s own semantics:\n      // first alternative to match AT ALL wins on ITS OWN greedy length, never\n      // compared against a later alternative's (possibly longer) match.\n      const lbl = mint('_alt')\n      lines.push(`${ind}${lbl}: {`)\n      for (const arm of shape.arms) {\n        const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n        lines.push(...m.setup)\n        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV} = ${m.end}; break ${lbl} }`)\n      }\n      lines.push(`${ind}}`)\n    }\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'chars') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.ranges)})) ${cur}++`,\n      ],\n      // `*` always matches (possibly empty); `+` needs at least one char.\n      ok: shape.minOne ? `${cur} > ${start}` : 'true',\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'ident') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}if (${start} < input.length && (${classCond(codeAt(start, firstChar), shape.head)})) {`,\n        `${ind}  ${cur} = ${start} + 1`,\n        `${ind}  while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.tail)})) ${cur}++`,\n        `${ind}}`,\n      ],\n      ok: `${cur} > ${start}`,\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'seq') {\n    const endV = mint('_e')\n    const okV = mint('_ok')\n    const runCond = (p: Extract<SeqPart, { part: 'run' }>, at: string) => {\n      const c = classCond(`input.charCodeAt(${at})`, p.ranges)\n      return p.negated ? `!(${c})` : `(${c})`\n    }\n    const lines = [`${ind}let ${endV} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`]\n    let first = true\n    for (const p of shape.parts) {\n      if (p.part === 'lit') {\n        const L = p.cps.length\n        const cond = litCond(endV, p.cps, first ? firstChar : undefined)\n        if (p.optional) {\n          lines.push(`${ind}  if (${endV} + ${L} <= input.length && (${cond})) ${endV} += ${L}`)\n        } else {\n          lines.push(`${ind}  if (!(${endV} + ${L} <= input.length && (${cond}))) break`)\n          lines.push(`${ind}  ${endV} += ${L}`)\n        }\n      } else if (p.part === 'run' && !p.unbounded) {\n        // Exactly one char: required (min 1) or optional (min 0).\n        if (p.min === 1) {\n          lines.push(`${ind}  if (!(${endV} < input.length && ${runCond(p, endV)})) break`)\n          lines.push(`${ind}  ${endV}++`)\n        } else {\n          lines.push(`${ind}  if (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        }\n      } else if (p.part === 'run') {\n        const s = mint('_s')\n        lines.push(`${ind}  const ${s} = ${endV}`)\n        lines.push(`${ind}  while (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        if (p.min === 1) lines.push(`${ind}  if (${endV} === ${s}) break`)\n      } else {\n        // `group` (\u00A78f): the group's own body is just another `ScanShape` \u2014\n        // recurse via `emitShapeMatch`, then splice its setup in as the body\n        // of a required-once check, an optional take, or a repeat loop.\n        const inner = emitShapeMatch(p.inner, endV, mint, `${ind}  `, first ? firstChar : undefined)\n        if (!p.unbounded) {\n          lines.push(...inner.setup)\n          if (p.min === 1) {\n            lines.push(`${ind}  if (!(${inner.ok})) break`)\n            lines.push(`${ind}  ${endV} = ${inner.end}`)\n          } else {\n            lines.push(`${ind}  if (${inner.ok}) ${endV} = ${inner.end}`)\n          }\n        } else {\n          const progV = mint('_prog')\n          lines.push(`${ind}  let ${progV} = false`)\n          lines.push(`${ind}  while (true) {`)\n          lines.push(...inner.setup)\n          lines.push(`${ind}    if (!(${inner.ok})) break`)\n          lines.push(`${ind}    ${endV} = ${inner.end}`)\n          lines.push(`${ind}    ${progV} = true`)\n          lines.push(`${ind}  }`)\n          if (p.min === 1) lines.push(`${ind}  if (!${progV}) break`)\n        }\n      }\n      first = false\n    }\n    lines.push(`${ind}  ${okV} = true`)\n    lines.push(`${ind}} while (false)`)\n    lines.push(`${ind}if (!${okV}) ${endV} = ${start}`)\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'litFold') {\n    const openLen = shape.open.length\n    const endV = mint('_end')\n    const checks = shape.open.map((cp, k) => {\n      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`\n      return foldEq(cVar, cp)\n    })\n    return {\n      setup: [\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${checks.join(' && ')})) ${endV} = ${start} + ${openLen}`,\n      ],\n      ok: `${endV} > ${start}`,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'until') {\n    const j = mint('_j')\n    const openLen = shape.open.length\n    const openChk = openLen === 1\n      ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n      : litCond(start, shape.open, firstChar)\n    return {\n      setup: [\n        `${ind}let ${j} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n        `${ind}  ${j} = ${start} + ${openLen}`,\n        `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`,\n        `${ind}}`,\n      ],\n      // An open-until-terminator always completes (stop char or EOF), so a matched\n      // open literal is a full match; `end === start` iff the open didn't match.\n      ok: `${j} > ${start}`,\n      end: j,\n    }\n  }\n\n  if (shape.kind === 'string') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const i = mint('_i')\n    const c2 = mint('_c')\n    const hard = stringHardStop(shape)\n    const ltLines = shape.escLineTerm\n      ? []\n      : (() => {\n          const c3 = mint('_c')\n          return [\n            `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,\n            `${ind}      if (${LINE_TERMINATORS.map(t => `${c3} === ${t}`).join(' || ')}) break`,\n          ]\n        })()\n    return {\n      setup: [\n        `${ind}let ${okV} = false`,\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,\n        `${ind}  let ${i} = ${start} + 1`,\n        `${ind}  while (${i} < input.length) {`,\n        `${ind}    const ${c2} = input.charCodeAt(${i})`,\n        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV} = ${i} + 1; break }`,\n        `${ind}    if (${c2} === ${BACKSLASH}) {`,\n        `${ind}      if (${i} + 1 >= input.length) break`,\n        ...ltLines,\n        `${ind}      ${i} += 2`,\n        `${ind}      continue`,\n        `${ind}    }`,\n        ...(hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : []),\n        `${ind}    ${i}++`,\n        `${ind}  }`,\n        `${ind}}`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  // delimited: <open>\u2026<close>, requires the close literal (unclosed \u21D2 no match).\n  const j = mint('_j')\n  const endV = mint('_end')\n  const openLen = shape.open.length\n  const closeLen = shape.close.length\n  const openChk = openLen === 1\n    ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n    : litCond(start, shape.open, firstChar)\n  const closeChk = litCond(j, shape.close)\n  return {\n    setup: [\n      `${ind}let ${j} = ${start}`,\n      `${ind}let ${endV} = ${start}`,\n      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n      `${ind}  ${j} = ${start} + ${openLen}`,\n      `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,\n      `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,\n      `${ind}}`,\n    ],\n    ok: `${endV} > ${start}`,\n    end: endV,\n  }\n}\n\n/**\n * One trivia-loop branch for a shape, dispatched on the current char `c`\n * (= charCodeAt(_e)). Advances `_e` and `continue`s ONLY on real progress\n * (`end > _e`) \u2014 an unterminated delimited/string token leaves `end === _e`, so\n * the loop stops there exactly as the interpreter's `oneOrMore(choice(\u2026))` would.\n */\nexport function scanBranch(shape: ScanShape, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join('\\n')\n}\n\n/**\n * A labeled branch: match one token and, on progress, log its [start, end,\n * kindIndex] trivia chunk. Same completion semantics as scanBranch.\n */\nexport function scanBranchLabeled(shape: ScanShape, kindIndex: number, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [\n    ...m.setup,\n    `    if (${m.end} > _e) {`,\n    `      if (_cap) {`,\n    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,\n    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,\n    `      }`,\n    `      _e = ${m.end}`,\n    `      continue`,\n    `    }`,\n  ].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, type Mint, scanShapeFromRegex, scanBranch, scanBranchLabeled } from './scannable-run.ts'\n\n/** Fresh, collision-free local names for one generated scan function. */\nfunction makeMint(): Mint {\n  let n = 0\n  return (prefix = '_v') => `${prefix}${n++}`\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\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 d = getCoreRegexDef(arm)\n  return d ? scanShapeFromRegex(d.source, d.flags) : 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 directDef = getCoreRegexDef(core)\n  if (directDef) {\n    const shape = scanShapeFromRegex(directDef.source, directDef.flags)\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  const mint = makeMint()\n  return [\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...shapes.map(s => scanBranch(s, mint)),\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 d = getCoreRegexDef(arm.parser)\n    const shape = d ? scanShapeFromRegex(d.source, d.flags) : 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  const mint = makeMint()\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, mint)),\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", "/**\n * Lower scannable regex shapes to tight `charCodeAt` scan loops for terminal\n * `regex()` combinators (PERF_IDEAS \u00A78). Trivia uses the SAME match core via\n * `scannable-run.ts` (`emitShapeMatch`); this module is just the terminal\n * wrapper: run the shared match, fail when it doesn't match, then slice the\n * value. Keeping one match core means terminal and trivia can never disagree on\n * what an incomplete token (unclosed string/comment) means.\n */\nimport { type ScanShape, emitShapeMatch } from './scannable-run.ts'\n\nexport type ScanEmitCtx = {\n  ind: string\n  pos: string\n  valueVar: string\n  /** Emit `if (cond) { failLine }` lines (no trailing blank). */\n  failIf: (cond: string) => string[]\n  fresh: (prefix?: string) => string\n}\n\n/** Emit stmts for one terminal regex match, or null when the shape is unsupported. */\nexport function emitScannableTerminal(\n  shape: ScanShape,\n  c: ScanEmitCtx,\n): { stmts: string[]; endVar: string } | null {\n  const m = emitShapeMatch(shape, c.pos, c.fresh, c.ind)\n  const stmts = [...m.setup]\n  // `chars*` matches unconditionally (possibly empty) \u2014 no failure branch needed.\n  if (m.ok !== 'true') stmts.push(...c.failIf(`!(${m.ok})`))\n  stmts.push(`${c.ind}const ${c.valueVar} = input.slice(${c.pos}, ${m.end})`)\n  return { stmts, endVar: m.end }\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 { staticExpected } from '../combinators/expect.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 { scanShapeFromRegex, parseClassRanges, emitShapeMatch, type ScanShape, type Mint } from './scannable-run.ts'\nimport { emitScannableTerminal } from './scannable-terminal.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport { buildReadsTrivia, buildReadsState } from './build-arity.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  /** Frozen constant expected-set arrays hoisted to module scope (_fx0 etc.) */\n  expectedDecls: string[]\n  /** Dedup map: array source \u2192 hoisted const name */\n  expectedMap: 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  /** Whether any node() elided trivia capture and needs the shared frozen empty log. */\n  needsEmptyTl?: boolean | undefined\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   * Whether a leaf failure should record its payload into `_ctx._fe`/`_ctx._fx`\n   * for an enclosing reader (node/choice/ref/withCtx/runtime) to propagate.\n   * Swallowers (optional, many/sepBy loop bodies, not) set this false around the\n   * sub-parse whose failure they discard, so the hot path pays nothing. Default\n   * true (safe: always record). Only meaningful together with `failLabel`.\n   */\n  recordFail: boolean\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\n/**\n * Hoist a COMPILE-TIME-CONSTANT expected-set array to a shared module-level\n * const and return its variable name. Leaf failures (literal, regex, keyword,\n * not, \u2026) have a fixed expected set, so recording it on the hot failure path\n * must NOT allocate a fresh array every time \u2014 a choice arm that misses or a\n * many/sepBy loop that terminates hits this on essentially every token. We store\n * a reference to the shared array instead (one pointer write, zero allocation).\n *\n * The shared array is NEVER mutated in place by generated code, and every path\n * that surfaces `_ctx._fx` as a user-facing ParseResult copies it first (see\n * `resultFromRecorded` / the dynamic direct-return in `failArrBody`), so the\n * public `expected` array stays fresh & independent. (We deliberately do NOT\n * `Object.freeze` it: a user grammar may define a rule named `Object`, which \u2014\n * once inlined as a local \u2014 would shadow the global and break the freeze call.)\n */\nfunction hoistExpected(ctx: Ctx, constArrSource: string): string {\n  let name = ctx.expectedMap.get(constArrSource)\n  if (name === undefined) {\n    name = `_fx${ctx.expectedDecls.length}`\n    ctx.expectedDecls.push(`const ${name} = ${constArrSource}`)\n    ctx.expectedMap.set(constArrSource, name)\n  }\n  return name\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  // Record the failure payload before breaking so an enclosing composite\n  // construct can propagate this (deepest) failure verbatim \u2014 parity with the\n  // interpreter, which returns the inner failure result. Recording is skipped\n  // when no consumer will read it (see `ctx.recordFail`): swallowers like\n  // optional/many/sepBy/not never inspect `_ctx._fx`, so a leaf failing inside\n  // them just breaks \u2014 the hot path (loop terminations, first-arm misses) pays\n  // nothing. The direct-return path is the final answer and needs no recording.\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return `break ${ctx.failLabel}`\n    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`\n  }\n  return failReturn(expected, posExpr)\n}\n\n/**\n * Like {@link failBody} but the caller already has an array source. When\n * `constant` (the default), the array is hoisted+frozen (zero-alloc hot path).\n * Pass `constant: false` for dynamic sources (e.g. `_ctx._fx`, a runtime concat)\n * that must be assigned verbatim.\n */\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return `break ${ctx.failLabel}`\n    const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`\n  }\n  // Direct-return (no enclosing fail label). A dynamic source may reference the\n  // shared frozen `_ctx._fx`; copy it so the (possibly frozen) constant never\n  // escapes into a user-facing result. Constant sources are inline literals.\n  if (!constant) return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`\n  return failReturnArr(expectedArr, posExpr)\n}\n\n/** Build a ParseResult from the recorded deepest failure, copying `_fx` so the\n * shared frozen array never escapes into user-facing results. */\nfunction resultFromRecorded(feExpr = '_ctx._fe', fxExpr = '_ctx._fx'): string {\n  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`\n}\n\n/**\n * Propagate the already-recorded deepest failure (`_ctx._fe`/`_ctx._fx`) rather\n * than synthesizing a coarse `[\"node\"]`-style placeholder. Used by composite\n * constructs whose interpreter counterpart returns the inner failure verbatim\n * (node, ref/lazy, withCtx, runtime fallback). `srcCtx` is the ctx var holding\n * the payload (`_ctx`, or a spread child ctx for withCtx).\n */\nfunction propagateFailBody(ctx: Ctx, srcCtx = '_ctx'): string {\n  if (srcCtx !== '_ctx') {\n    // withCtx ran on a spread child ctx; copy its recorded failure back (only\n    // when a consumer will read it) before propagating.\n    if (ctx.failLabel) {\n      if (!ctx.recordFail) return `break ${ctx.failLabel}`\n      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`\n    }\n    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`\n  }\n  // Same-ctx: `_ctx._fx` already holds the deepest failure \u2014 just break/return.\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return resultFromRecorded()\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): 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      // ref/lazy returns the inner failure verbatim \u2014 propagate the recorded\n      // deepest failure (shares _ctx with the named fn), not a \"parser\" label.\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx)),\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// A first code point that keys a switch case is only worth enumerating when the\n// arm dispatches on a few DISCRETE points (keyword/operator first chars). A wide\n// range (a char-class arm like `[a-z]+`) would explode into dozens of `case`\n// labels, so those keep the if/else range-comparison form.\nconst SWITCH_RANGE_LIMIT = 4\nconst SWITCH_MAX_CASES = 48\nconst SWITCH_MIN_CASES = 3\n\n// Benchmark/test-only hook: force the `if/else if` disjoint-dispatch form so it\n// can be A/B'd against the `switch` jump table in the same process. Defaults to\n// off \u2014 production always uses planDisjointDispatch. See bench/codegen-ab.ts.\nlet _forceDisjointIf = false\nexport function __setForceDisjointIf(on: boolean): void { _forceDisjointIf = on }\n\n/**\n * Choose the dispatch form for a *disjoint* choice. Returns per-arm case code\n * points for a `switch` (jump table) when every arm keys off a small discrete\n * set, or `if` to keep the range-comparison `if/else if` chain. The arms are\n * pairwise-disjoint by construction, so each code point maps to exactly one arm.\n */\nfunction planDisjointDispatch(\n  parsers: ReadonlyArray<Combinator<unknown>>,\n): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const p of parsers) {\n    const fs = p._meta.firstSet\n    if (fs.kind !== 'ranges') return { kind: 'if' } // any/empty \u2192 no discrete keys\n    const pts: number[] = []\n    for (const r of fs.ranges) {\n      if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\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  /**\n   * When true, the caller DISCARDS this failure (optional/many/sepBy/not) \u2014 the\n   * inner leaves need not record `_ctx._fx`, since nobody reads it. Suppresses\n   * the hot-path failure bookkeeping for the sub-parse.\n   */\n  swallow = false,\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  const savedRecord = ctx.recordFail\n  ctx.failLabel = lbl\n  ctx.indent    = savedIndent + 1\n  if (swallow) ctx.recordFail = false\n  const r = emit(inner, ctx, pos)\n  ctx.failLabel = savedLabel\n  ctx.indent    = savedIndent\n  ctx.recordFail = savedRecord\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\n/**\n * Above this length, an unrolled `charCodeAt` chain stops paying for itself:\n * measured crossover where native `startsWith` wins on runtime is ~256\u2013512\n * chars, but the unrolled chain's *generated source* grows ~4\u201330\u00D7 faster than\n * `startsWith`'s near-constant call site (see PERF_IDEAS.md). No literal in a\n * real grammar (keywords, punctuation) gets remotely close to this \u2014 the\n * longest in this repo's example grammars is `important` (9 chars) \u2014 so this\n * threshold exists to cap codegen bloat on a pathological literal, not because\n * `startsWith` is faster there.\n */\nconst CHARCODE_CHAIN_MAX = 16\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 <= CHARCODE_CHAIN_MAX) {\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\n/**\n * Fast path for `keywords()`/`word()`/`makeWord()`: each word is a FIXED\n * literal (optionally wrapped in the shared boundary lookahead), so this\n * reuses the exact `seq`/`litFold`/`lookahead` `ScanShape` machinery from\n * `scannable-run.ts` (PERF_IDEAS \u00A78b) instead of one `RegExp.exec` alternation\n * per match. Unconditionally ambiguity-safe: `trailingBacktrackClass` treats a\n * single-literal `seq` and `litFold` as fixed-length (no quantifier to\n * backtrack), so wrapping either in a lookahead is safe for ANY boundary class\n * \u2014 no `seqIsUnambiguous`-style check is needed here.\n *\n * Declines (returns `null`, caller falls back to the regex alternation) for:\n *   - an empty-string keyword (degenerate; not worth special-casing)\n *   - a keyword containing an astral (surrogate-pair) code point \u2014 the `seq`/\n *     `litFold` codegen advances one `charCodeAt` UTF-16 unit per code POINT,\n *     which only holds for the BMP (same reason `scanShapeFromRegex` refuses\n *     the `u` flag entirely); real keyword sets are BMP identifiers, so this\n *     is a defensive, not a practical, limitation\n *   - a boundary class this file can't parse (defensive; `parseClassRanges`\n *     handles every realistic boundary string, e.g. `_0-9A-Za-z`)\n *   - `caseInsensitive` combined with a boundary \u2014 the boundary class would\n *     ALSO need ASCII case-folding to match the original regex's `/i` flag\n *     (the general \"`/i` on a char class\" problem, PERF_IDEAS \u00A78d, not yet\n *     built), so this combination is left on the safe, slower path rather\n *     than risk silently narrowing which chars the boundary excludes.\n */\nfunction emitKeywordsFast(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER | null {\n  if (def.words.length === 0 || def.words.some(w => w.length === 0)) return null\n  if (def.words.some(w => Array.from(w).length !== w.length)) return null\n  if (def.caseInsensitive && def.boundary) return null\n\n  let boundary: { ranges: Array<[number, number]>; negated: boolean } | null = null\n  if (def.boundary) {\n    let body = def.boundary\n    const negated = body.startsWith('^')\n    if (negated) body = body.slice(1)\n    const ranges = parseClassRanges(body)\n    if (!ranges) return null\n    boundary = { ranges, negated }\n  }\n\n  const mint: Mint = (prefix = '_v') => v(ctx, prefix)\n  const lbl = v(ctx, '_kwLbl')\n  const valV = v(ctx, '_kwv')\n  const endV = v(ctx, '_kwe')\n  const bodyInd = ind(ctx) + '  '\n\n  const tries: string[] = []\n  for (const w of def.words) {\n    const cps = Array.from(w, ch => ch.codePointAt(0)!)\n    let shape: ScanShape = def.caseInsensitive\n      ? { kind: 'litFold', open: cps }\n      : { kind: 'seq', parts: [{ part: 'lit', cps, optional: false }] }\n    if (boundary) {\n      shape = { kind: 'lookahead', inner: shape, ranges: boundary.ranges, classNegated: boundary.negated, negative: true }\n    }\n    const m = emitShapeMatch(shape, pos, mint, bodyInd)\n    tries.push(\n      ...m.setup,\n      // Slice from input rather than reusing the literal word: `caseInsensitive`\n      // must return the text as it actually appeared (e.g. \"ABC\" for keyword\n      // \"abc\"), matching what the original `RegExp.exec()[0]` returned.\n      `${bodyInd}if (${m.ok}) { ${valV} = input.slice(${pos}, ${m.end}); ${endV} = ${m.end}; break ${lbl} }`,\n    )\n  }\n\n  const stmts = [\n    `${ind(ctx)}let ${valV} = '', ${endV} = ${pos}`,\n    `${ind(ctx)}${lbl}: {`,\n    ...tries,\n    `${ind(ctx)}}`,\n    // Every word has length >= 1 (checked above), so a real match always\n    // advances past `pos` \u2014 `endV === pos` only happens when no candidate matched.\n    ...emitIfFail(ctx, `${endV} === ${pos}`, failBody(ctx, '\"keyword\"', pos)),\n  ]\n  stmts.push(...emitLeafCapture(ctx, valV, pos, endV))\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitKeywords(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER {\n  const fast = emitKeywordsFast(def, ctx, pos)\n  if (fast) return fast\n\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 expectedStr = JSON.stringify(`/${def.source}/`)\n  const shape = scanShapeFromRegex(def.source, def.flags)\n  if (shape) {\n    const vv = v(ctx)\n    const scanned = emitScannableTerminal(shape, {\n      ind: ind(ctx),\n      pos,\n      valueVar: vv,\n      failIf: (cond: string) => emitIfFail(ctx, cond, failBody(ctx, expectedStr, pos)),\n      fresh: (prefix?: string) => v(ctx, prefix),\n    })\n    if (scanned) {\n      const stmts = [...scanned.stmts, ...emitLeafCapture(ctx, vv, pos, scanned.endVar)]\n      return { stmts, valueVar: vv, endVar: scanned.endVar }\n    }\n  }\n\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 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\n/**\n * Deep-first `expected` labels for a choice's arms \u2014 the concatenation of each\n * arm's leftmost-leaf expected set, matching what the interpreter collects when\n * no arm's first-set matches (choice.ts) and what expect()'s staticExpected()\n * reports. Falls back to the arm's tag only for arms with no static expectation\n * (e.g. runtime-fallback combinators), preserving the previous behaviour there.\n */\nfunction staticExpectedArr(parsers: Combinator<unknown>[]): string {\n  return JSON.stringify(parsers.flatMap(p => {\n    const e = staticExpected(p)\n    return e.length > 0 ? e : [p._tag]\n  }))\n}\n\n/**\n * True when `p` can only fail at its own start position (its failure span is\n * `{pos,pos}` and its expected set is a fixed label). Such disjoint-choice arms\n * can be emitted inline: their leaf failure already matches the interpreter's\n * `{expected: <label>, span: {pos,pos}}`. Composite arms (sequence, node, \u2026) can\n * fail deeper, so they must be wrapped to re-anchor the span at the choice pos.\n */\nfunction failsAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'literal': case 'regex': case 'keywords': case 'guard': case 'not':\n      return true\n    case 'transform': case 'label':\n      return failsAtStart(d.parser)\n    default:\n      return false\n  }\n}\n\n/** Hoisted module-level const for one arm's static `expected` labels. */\nfunction armStaticExpected(ctx: Ctx, p: Combinator<unknown>): string {\n  return hoistExpected(ctx, staticExpectedArr([p]))\n}\n\n/**\n * True when `p` can succeed at `pos` without consuming input (e.g. a starred\n * regex, optional, many). Such arms must still be tried even when the current\n * code point is outside their first-set \u2014 skipping them would change semantics.\n */\nfunction canMatchEmptyAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'regex':\n      return /(?:[*?]|\\{0,|\\{\\d*,)/.test(d.source)\n    case 'optional': return true\n    case 'many': return true\n    case 'transform': case 'label':\n      return canMatchEmptyAtStart(d.parser)\n    case 'literal':\n      return d.value.length === 0\n    default:\n      return false\n  }\n}\n\n/** Emit a first-set guard when the arm cannot match empty and has a finite first-set. */\nfunction needsFirstSetGuard(p: Combinator<unknown>): boolean {\n  const fs = p._meta.firstSet\n  return fs.kind !== 'any' && !canMatchEmptyAtStart(p)\n}\n\n/**\n * Emit one arm of a disjoint choice, assigning its value/end to `valV`/`endV`.\n * Leaf arms (failsAtStart) are inlined \u2014 their leaf failure already matches the\n * interpreter. Composite arms are wrapped so that on failure the choice reports\n * the arm's deep `expected` (via _ctx._fx) but re-anchors the span at the choice\n * position `pos` \u2014 exactly what the interpreter's disjoint dispatch returns.\n */\nfunction emitDisjointArm(p: Combinator<unknown>, ctx: Ctx, pos: string, valV: string, endV: string): string[] {\n  if (failsAtStart(p)) {\n    const r = emit(p, ctx, pos)\n    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`]\n  }\n  const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n  return [\n    ...stmts,\n    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, '_ctx._fx', pos, false)),\n    `${ind(ctx)}${valV} = ${valVar}`,\n    `${ind(ctx)}${endV} = ${endVar}`,\n  ]\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = staticExpectedArr(def.parsers)\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    const plan = _forceDisjointIf ? { kind: 'if' as const } : planDisjointDispatch(def.parsers)\n\n    // Switch (jump table) when arms key off a few discrete first code points.\n    if (plan.kind === 'switch') {\n      stmts.push(`${ind(ctx)}switch (${codeV}) {`)\n      ctx.indent++\n      for (let i = 0; i < def.parsers.length; i++) {\n        const p = def.parsers[i]!\n        for (const cp of plan.cases[i]!) stmts.push(`${ind(ctx)}case ${cp}:`)\n        stmts.push(`${ind(ctx)}{`)\n        ctx.indent++\n        stmts.push(\n          ...emitDisjointArm(p, ctx, pos, valV, endV),\n          `${ind(ctx)}break`,\n        )\n        ctx.indent--\n        stmts.push(`${ind(ctx)}}`)\n      }\n      stmts.push(`${ind(ctx)}default: ${failArrBody(ctx, allExpected, pos)}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n      return { stmts, valueVar: valV, endVar: endV }\n    }\n\n    // Otherwise if/else if with range comparisons (cheaper for char-class arms).\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      stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV))\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  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  // On no-match the interpreter returns the super-regex arm's failure verbatim\n  // (choice.ts) \u2014 report only the regex's expected, not every classified literal.\n  const regexExpected = JSON.stringify(staticExpected(superParser))\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, regexExpected, 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  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 codeV   = v(ctx, '_chcode')\n  // For a TOTAL failure we report the concatenation of each tried arm's deep\n  // `expected` (interpreter parity). To keep the hot success path allocation-free\n  // (a choice that ultimately matches must NOT pay for error bookkeeping), each\n  // failed arm snapshots its expected into a scalar slot (a pointer store, no\n  // array/spread). Leaf arms that fail-at-start use a hoisted static const;\n  // composite arms snapshot `_ctx._fx`. The concat array is materialized only in\n  // the rare all-arms-failed branch. Auto-not-rejected arms leave their slot\n  // unset \u2014 matching choice.ts.\n  const slots = def.parsers.map(() => v(ctx, '_cfx'))\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n    `${ind0}let ${slots.join(', ')}`,\n    `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\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    const atStart = failsAtStart(p)\n    const staticFx = armStaticExpected(ctx, p)\n    const fsGuard = needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null\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    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    const failSlot = atStart ? staticFx : '_ctx._fx'\n\n    stmts.push(`${ind0}if (${skipCond}) {`)\n    if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`)\n    ctx.indent += fsGuard ? 2 : 1\n\n    if (markLeaves) {\n      stmts.push(\n        `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,\n        `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`,\n      )\n    }\n    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart)\n    stmts.push(...armStmts)\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(`${ind(ctx)}if (${okVar}) {`)\n      stmts.push(`${ind(ctx)}  const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`)\n      stmts.push(`${ind(ctx)}  if (!(${rejectCond})) {`)\n      stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`)\n      stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`)\n      stmts.push(`${ind(ctx)}    ${resOkV} = true`)\n      stmts.push(`${ind(ctx)}  }`)\n      stmts.push(`${ind(ctx)}}`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`)\n      if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ''} }`)\n    }\n\n    ctx.indent -= fsGuard ? 2 : 1\n    if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`)\n    stmts.push(`${ind0}}`)\n  }\n  const concatExpr = `[${slots.map(s => `...(${s} || [])`).join(', ')}]`\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)))\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, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, 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 > CHARCODE_CHAIN_MAX) 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, true)\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, true)\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, true)\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, true)\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, true)\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, true)\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, true)\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, true)\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, true)\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  // not() discards the inner failure (inner failing = not succeeding), so the\n  // inner sub-parse need not record \u2014 swallow it.\n  const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true)\n  // not() fails (at its own pos) when the inner parser SUCCEEDS; the interpreter\n  // reports `not(<innerTag>)` as the expected token \u2014 match that label exactly.\n  const label = JSON.stringify(`not(${def.parser._tag})`)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, label, 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  // Arity-gated elision: when the build provably never reads the trivia (4th) or\n  // state (5th) arg, skip that capture entirely. The mk-inline path reads\n  // `tlV.length` for `localTriviaLen`, so it always keeps trivia capture.\n  const capturesTrivia = mkType !== null || buildReadsTrivia(def)\n  const clonesState = buildReadsState(def)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const tlV = capturesTrivia ? v(ctx, '_tl') : '_EMPTY_TL'\n  if (!capturesTrivia) ctx.needsEmptyTl = true\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  const allocStmt = capturesTrivia\n    ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`\n    : `${i}const ${chV} = [], ${rawV} = []`\n  // When not capturing, set _ctx._cstTriviaLog = undefined so inner trivia terminals'\n  // `if (_ctx._cstTriviaLog !== undefined)` guard short-circuits (no per-token push).\n  const innerTl = capturesTrivia ? tlV : 'undefined'\n  const stmts: string[] = [\n    allocStmt,\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 = ${innerTl}`,\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  // node() returns the inner failure verbatim (interpreter parity) \u2014 propagate\n  // the recorded deepest failure, not a coarse [\"node\"] at the node's start.\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)))\n\n  let stV = 'undefined'\n  if (clonesState) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  }\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  // collapse: a single captured child IS the value (leaf \u2192 its string, else as-is);\n  // build is skipped (short-circuited by the ternary). Mirrors node.ts.\n  const finalExpr = def.collapse\n    ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`\n    : ndExpr\n  stmts.push(\n    `${i}const ${ndV} = ${finalExpr}`,\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  // The runtime parser IS the real combinator, so its result is exactly the\n  // interpreter's \u2014 record its failure payload and propagate it verbatim (only\n  // when a consumer will read it).\n  const failStmt = ctx.failLabel\n    ? (ctx.recordFail\n        ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }`\n        : `break ${ctx.failLabel}`)\n    : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failStmt),\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    const savedRecord    = ctx.recordFail\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in fn body)\n    // A named fn is compiled ONCE but shared across every call site, so its body\n    // must always record `_ctx._fx` \u2014 the caller (emitNamedFnCall) decides via\n    // its own recordFail whether to propagate. Baking the first caller's\n    // (possibly swallowed) recordFail into the shared body would leave `_ctx._fx`\n    // unset for other callers that DO read it.\n    ctx.recordFail = true\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n    ctx.recordFail = savedRecord\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)\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: ${JSON.stringify(staticExpected(def.parser))} }`,\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        const savedRecord    = ctx.recordFail\n        ctx.indent    = 1\n        ctx.failLabel = '_pfail'  // failures break _pfail (same as emitLazy)\n        ctx.recordFail = true     // shared body always records (see emitLazy)\n        const innerR = emit(innerParser, ctx, '_pos')\n        ctx.indent    = savedIndent\n        ctx.failLabel = savedFailLabel\n        ctx.recordFail = savedRecord\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          // withCtx runs on a spread child ctx \u2014 copy its recorded failure back\n          // and propagate the inner failure verbatim (interpreter parity).\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx, rv)),\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    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\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  const emptyTlDecls = ctx.needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []\n\n  const source = [\n    ...emptyTlDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\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    ...emptyTlDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\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    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\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.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : '',\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.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 emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : ''\n  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    emptyTlDecl,\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.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'\nimport { staticExpected } from './expect.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  // Precompute the expected set from the combinator's structure so the ParseError\n  // reports the same expectation in the interpreter and the compiled build (the\n  // compiled path can't rebuild the runtime `expected` array \u2014 same design as expect()).\n  const expected = staticExpected(combinator)\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,\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 { 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 * Automatic list recovery \u2014 tolerant `sepBy` / `many` for editor-grade parsing.\n *\n * Plain `sepBy` / `many` stop at the first item they can't parse. Inside a\n * delimited list (`[ \u2026 ]`, `{ \u2026 }`, an argument list) that means one malformed\n * element truncates the whole list, which is exactly the wrong behavior for an\n * IDE re-parsing broken input. These variants instead skip a bad element up to\n * the next separator (or the list terminator), record a `ParseError` in its\n * place, and keep going \u2014 so the rest of the list still parses.\n *\n * They are built entirely from existing combinators (`recover`, `sepBy`, `many`,\n * `not`, `sequence`, `transform`), so the compiler and CST capture handle them\n * with no special cases \u2014 the macro build behaves identically to the interpreter.\n *\n * The `until` terminator (the list's closing delimiter, matched but not consumed)\n * is required: it's how an *empty* list is told apart from a *malformed* first\n * element. `until` must not overlap with what a valid item can start with.\n */\nimport type { Combinator } from '../types.ts'\nimport { sequence } from './sequence.ts'\nimport { choice } from './choice.ts'\nimport { many, sepBy } from './repeat.ts'\nimport { not } from './not.ts'\nimport { recover, type ParseError } from './recover.ts'\nimport { transform } from './map.ts'\n\n/**\n * One tolerant element: fail cleanly at the terminator (so the list can end),\n * otherwise parse the item or recover the junk before it up to `sentinel`.\n */\nfunction tolerantElement<T>(\n  item: Combinator<T>,\n  sentinel: Combinator<unknown>,\n  until: Combinator<unknown>,\n): Combinator<T | ParseError> {\n  const el = transform(\n    sequence(not(until), recover(item, sentinel)),\n    ([, value]) => value,\n  )\n  // Let the macro inline this library-internal unwrap instead of embedding the\n  // closure (codegen reads map-fn source from def.fnSrc; see balanced()).\n  if (el._def.tag === 'transform') el._def.fnSrc = '([, value]) => value'\n  return el as Combinator<T | ParseError>\n}\n\n/**\n * Like `sepBy`, but tolerant: a malformed element is skipped up to the next\n * `separator` or `until` and recorded as a `ParseError` in the result array,\n * instead of ending the list. An empty list (next token is `until`) yields `[]`\n * with no error.\n *\n *   const elements = sepByRecover(value, literal(','), literal(']'))\n *   const array = sequence(literal('['), elements, literal(']'))\n *   // \"[1,,3]\" \u2192 [1, ParseError, 3] ; error collected via { recover: true }\n */\nexport function sepByRecover<T>(\n  item: Combinator<T>,\n  separator: Combinator<unknown>,\n  until: Combinator<unknown>,\n): Combinator<(T | ParseError)[]> {\n  const sentinel = choice(separator, until)\n  return sepBy(tolerantElement(item, sentinel, until), separator)\n}\n\n/**\n * Like `many`, but tolerant: junk that isn't a valid item (and isn't the `until`\n * terminator) is skipped up to `until` and recorded as a `ParseError`, instead\n * of stopping the repetition. With no separator to resync on, a bad run is\n * captured as a single error up to the terminator.\n *\n *   const items = manyRecover(statement, literal('}'))\n */\nexport function manyRecover<T>(\n  item: Combinator<T>,\n  until: Combinator<unknown>,\n): Combinator<(T | ParseError)[]> {\n  return many(tolerantElement(item, until, until))\n}\n", "/**\n * Incremental parse 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 ParseDocOptions<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 ParseDoc<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): ParseDoc<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<ParseDocOptions<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\ntype SpanChild = { span: { start: number; end: number }; children?: readonly unknown[] }\n\n/**\n * Deep-shift every absolute span in a subtree by `delta`. Used for nodes that\n * sit *after* a length-changing edit: their content didn't change but their\n * offsets moved. Plain-object path only (see `graftAndShift`).\n */\nfunction shiftSpans<T>(child: T, delta: number): T {\n  const c = child as unknown as SpanChild\n  const span = { start: c.span.start + delta, end: c.span.end + delta }\n  if (Array.isArray(c.children)) {\n    return { ...(c as object), span, children: c.children.map((g) => shiftSpans(g, delta)) } as unknown as T\n  }\n  return { ...(c as object), span } as unknown as T\n}\n\n/**\n * Graft `newNode` at `path` for a length-changing edit (`delta !== 0`):\n * children before the edit are shared by reference, the edited child is\n * replaced, children after it are span-shifted by `delta`, and each ancestor's\n * `span.end` grows by `delta`. Absolute-offset trees must touch every node after\n * the edit \u2014 that's inherent \u2014 but everything before it is still shared.\n */\nfunction graftAndShift<N extends NodeLike>(root: N, path: number[], newNode: N, delta: number): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const oldChildren = root.children as ReadonlyArray<N | CSTLeaf | CSTError>\n  const newChildren = oldChildren.map((child, i) => {\n    if (i < idx) return child\n    if (i === idx) {\n      return rest.length === 0 ? newNode : graftAndShift(child as N, rest, newNode, delta)\n    }\n    return shiftSpans(child, delta)\n  })\n  return {\n    ...root,\n    span: { start: root.span.start, end: root.span.end + delta },\n    children: newChildren,\n  } as N\n}\n\n// ---------------------------------------------------------------------------\n// Document\n// ---------------------------------------------------------------------------\n\nclass ParseDocImpl<N extends NodeLike> implements ParseDoc<N> {\n  private readonly _registry: Registry<N>\n  private readonly _rootRule: string\n  private readonly _opts: ParseDocOptions<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: ParseDocOptions<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): ParseDoc<N> {\n    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to)\n    const reparse = () => parseDoc(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        // delta === 0: spans are unchanged, so the spine graft (sharing every\n        // untouched sibling by reference) is already correct.\n        if (delta === 0) {\n          const newTree = replaceAtPath(rebuild, this.tree, path, r.value)\n          return new ParseDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput)\n        }\n        // Length-changing edit: nodes after the edit must have their absolute\n        // spans shifted. A custom `rebuild` can't have its spans shifted safely\n        // (it may be a class instance), so fall back to a full, correct reparse.\n        if (this._opts.rebuild) return reparse()\n        const newTree = graftAndShift(this.tree, path, r.value, delta)\n        return new ParseDocImpl(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 ParseDoc that can\n * be incrementally re-parsed via `.edit()`.\n */\nexport function parseDoc<N extends NodeLike>(\n  registry: Registry<N>,\n  rootRule: string,\n  input: string,\n  opts: ParseDocOptions<N> = {},\n): ParseDoc<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 ParseDocImpl(registry, rootRule, opts, r.value, [], input)\n  }\n  return new ParseDocImpl(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", "/**\n * Tree traversal for the CST/AST a grammar produces. Pars\u00E9man hands back a plain\n * object tree, so you *can* recurse it yourself \u2014 these helpers save you from\n * re-writing the same recursion for diagnostics, folding, or lowering a tree.\n *\n * Two entry points:\n *   - `walk`          \u2014 imperative depth-first traversal with enter/leave hooks.\n *   - `createVisitor` \u2014 Chevrotain-style dispatch keyed on each node's `type`.\n *\n * Both default to the built-in CST shape (`CSTChild` \u2014 the `node()` / leaf / error\n * union), so with no annotation you get precise typing out of the box. Parsing to\n * a custom AST? Pass your node type as a generic: `walk<MyNode>(root, \u2026)`.\n */\nimport type { CSTChild } from './types.ts'\n\n/**\n * The minimal shape these helpers traverse: a `_tag`, an optional rule `type`,\n * and optional structural `children`. The built-in `CSTChild` satisfies it, and\n * so does any custom AST node (that's what the generic override targets).\n */\nexport type Walkable = {\n  readonly _tag: string\n  readonly type?: string\n  readonly children?: ReadonlyArray<Walkable>\n}\n\nexport interface WalkVisitor<N extends Walkable = CSTChild, C = undefined> {\n  /**\n   * Called on entering a node, before its children. Return `false` to skip\n   * descending into this node's children (`leave` still runs).\n   */\n  enter?(node: N, parent: N | null, ctx: C): boolean | void\n  /** Called on leaving a node, after its children. */\n  leave?(node: N, parent: N | null, ctx: C): void\n}\n\n/**\n * Depth-first traversal. Visits `root`, then each structural child in order.\n * `ctx` is threaded to both hooks unchanged (use it as an accumulator).\n *\n * Defaults to the CST shape; override with `walk<MyNode>(root, \u2026)`:\n *\n *   const idents: string[] = []\n *   walk(tree, {\n *     enter(node) {\n *       if (node._tag === 'leaf') idents.push(node.value)\n *     },\n *   })\n */\nexport function walk<N extends Walkable = CSTChild, C = undefined>(\n  root: N,\n  visitor: WalkVisitor<N, C>,\n  ctx: C = undefined as C,\n): void {\n  const go = (node: N, parent: N | null): void => {\n    const descend = visitor.enter ? visitor.enter(node, parent, ctx) : undefined\n    const children = node.children as ReadonlyArray<N> | undefined\n    if (descend !== false && Array.isArray(children)) {\n      for (const child of children) go(child, node)\n    }\n    visitor.leave?.(node, parent, ctx)\n  }\n  go(root, null)\n}\n\nexport interface VisitApi<R, N extends Walkable = CSTChild> {\n  /** Dispatch a node to its handler (by `type`); returns the handler's result. */\n  visit(node: N): R | undefined\n  /** Visit every structural child, collecting the defined results in order. */\n  visitChildren(node: N): R[]\n}\n\nexport type VisitorHandlers<R, N extends Walkable = CSTChild> = Record<\n  string,\n  (node: N, api: VisitApi<R, N>) => R\n>\n\n/**\n * Build a visitor that dispatches on each node's `type` \u2014 the direct analog of a\n * generated CST-visitor base class. Handlers are keyed by rule name and receive\n * an `api` with `visit` / `visitChildren` to recurse:\n *\n *   const evalExpr = createVisitor<number>({\n *     Num: (n) => Number((n as NumNode).value),\n *     Add: (n, api) => api.visitChildren(n).reduce((a, b) => a + b, 0),\n *   })\n *   const total = evalExpr(tree)\n *\n * Defaults to the CST shape; override the return type and node type together with\n * `createVisitor<number, MyNode>({ \u2026 })`. A node whose `type` has no handler\n * falls through to visiting its children (results discarded), so partial visitors\n * work without listing every rule.\n */\nexport function createVisitor<R = void, N extends Walkable = CSTChild>(\n  handlers: VisitorHandlers<R, N>,\n): (node: N) => R | undefined {\n  const api: VisitApi<R, N> = {\n    visit(node) {\n      const handler = node.type !== undefined ? handlers[node.type] : undefined\n      if (handler) return handler(node, api)\n      api.visitChildren(node)\n      return undefined\n    },\n    visitChildren(node) {\n      const out: R[] = []\n      const children = node.children as ReadonlyArray<N> | undefined\n      if (Array.isArray(children)) {\n        for (const child of children) {\n          const r = api.visit(child)\n          if (r !== undefined) out.push(r)\n        }\n      }\n      return out\n    },\n  }\n  return (node) => api.visit(node)\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", "label", "cp", "ind", "endV", "openLen", "j", "openChk", "unwrapTrivia", "trivia", "escapeRegExp", "body", "trivia", "vv", "stmts", "r", "litCond", "label", "parser", "fnName", "mv", "walk", "skip", "emit", "node", "newTree", "node", "node"]
 }