parseman 0.1.0

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/combinators/first-set.ts", "../src/combinators/literal.ts", "../src/combinators/regex.ts", "../src/combinators/sequence.ts", "../src/combinators/choice.ts", "../src/combinators/repeat.ts", "../src/combinators/ref.ts", "../src/combinators/parser.ts", "../src/combinators/not.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/compiler/codegen.ts", "../src/combinators/guard.ts", "../src/combinators/withCtx.ts", "../src/combinators/recover.ts", "../src/combinators/scanTo.ts", "../src/cst/incremental.ts", "../src/cst/grammar.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 { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { fromChar, empty } from './first-set.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 { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: 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 (_ctx._cstLeaves) (_ctx._cstLeaves as typeof leaf[]).push(leaf)\n        if (_ctx._cstRawChildren) (_ctx._cstRawChildren as typeof leaf[]).push(leaf)\n        return { ok: true, value: slice, span }\n      }\n      return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: 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'\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 { ok: false, expected: [`/${source}/`], span: { start: pos, end: pos } }\n      }\n      const span = { start: pos, end: pos + m[0]!.length }\n      const leaf = { _tag: 'leaf', value: m[0]!, span }\n      if (ctx._cstLeaves) (ctx._cstLeaves as typeof leaf[]).push(leaf)\n      if (ctx._cstRawChildren) (ctx._cstRawChildren as typeof leaf[]).push(leaf)\n      return { ok: true, value: m[0]!, span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'\nimport { empty } from './first-set.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        // skip trivia between terms (not before the first)\n        if (ctx.trivia && i > 0) {\n          const tr = ctx.trivia.parse(input, cur, { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user })\n          if (tr.ok) {\n            if (ctx._cstRawChildren && tr.span.end > tr.span.start)\n              (ctx._cstRawChildren as unknown[]).push({ _tag: 'trivia', value: input.slice(tr.span.start, tr.span.end), span: tr.span })\n            cur = tr.span.end\n          }\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 {\n  Combinator, ParseContext, ParseResult, ParserMeta, FirstSet,\n  AutoNotCheck, CharRange, ChoiceStrategy, GatedArm,\n} from '../types.ts'\nimport { union, intersects } from './first-set.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.parser : a)) as Combinator<unknown>[]\n  const gates   = args.map(a => ('gate' in a ? a.gate   : null)) as (((user: 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.user)) continue   // gate blocks this arm\n        const result = parsers[i]!.parse(input, pos, ctx)\n        if (!result.ok) { expected.push(...result.expected); continue }\n        const checks = autoNot[i]\n        if (checks && autoNotFires(input, result.span.end, checks)) continue\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  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, ParseResult, ParserMeta } from '../types.ts'\n\nexport function many<T>(parser: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: parser._meta.firstSet,\n    canMatchNewline: parser._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'many',\n    _meta: meta,\n    _def: { tag: 'many', parser: parser 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 result = parser.parse(input, cur, ctx)\n        if (!result.ok) break\n        if (result.span.end === cur) break\n        values.push(result.value)\n        cur = result.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function oneOrMore<T>(parser: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: parser._meta.firstSet,\n    canMatchNewline: parser._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'oneOrMore',\n    _meta: meta,\n    _def: { tag: 'oneOrMore', parser: parser as Combinator<unknown>, min: 1 },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = parser.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 result = parser.parse(input, cur, ctx)\n        if (!result.ok) break\n        if (result.span.end === cur) break\n        values.push(result.value)\n        cur = result.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function optional<T>(parser: Combinator<T>): Combinator<T | null> {\n  const meta: ParserMeta = {\n    firstSet: parser._meta.firstSet,\n    canMatchNewline: parser._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'optional',\n    _meta: meta,\n    _def: { tag: 'optional', parser: parser as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {\n      const result = parser.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T>\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n\nexport function sepBy<T, S>(parser: Combinator<T>, separator: Combinator<S>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: parser._meta.firstSet,\n    canMatchNewline: parser._meta.canMatchNewline || separator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'sepBy',\n    _meta: meta,\n    _def: { tag: 'sepBy', parser: parser as Combinator<unknown>, separator: separator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = parser.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        let sepPos = cur\n        if (ctx.trivia) { const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user }; const tr = ctx.trivia.parse(input, sepPos, triviaCtx); if (tr.ok) { if (ctx._cstRawChildren && tr.span.end > tr.span.start) (ctx._cstRawChildren as unknown[]).push({ _tag: 'trivia', value: input.slice(tr.span.start, tr.span.end), span: tr.span }); sepPos = tr.span.end } }\n        const sep = separator.parse(input, sepPos, ctx)\n        if (!sep.ok) break\n        let nextPos = sep.span.end\n        if (ctx.trivia) { const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user }; const tr = ctx.trivia.parse(input, nextPos, triviaCtx); if (tr.ok) { if (ctx._cstRawChildren && tr.span.end > tr.span.start) (ctx._cstRawChildren as unknown[]).push({ _tag: 'trivia', value: input.slice(tr.span.start, tr.span.end), span: tr.span }); nextPos = tr.span.end } }\n        const next = parser.parse(input, nextPos, ctx)\n        if (!next.ok) break\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 mutually recursive grammar parser without forward declarations.\n *\n * Pass a factory that receives all rule names as parser references (via a Proxy)\n * and returns a record of parser definitions. parser() handles creating ref()\n * placeholders and wiring them up \u2014 the user never sees ref() at all.\n *\n *   const { value } = parser(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 parser 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 *   parser<{ 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 parser<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 `parser` fails;\n * fails when `parser` 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(parser: 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: 'unknown',\n    _meta: meta,\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      const result = parser.parse(input, pos, ctx)\n      if (result.ok) {\n        return { ok: false, expected: [`not(${parser._tag})`], span: { start: pos, end: pos } }\n      }\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\n\nexport function transform<T, U>(\n  parser: Combinator<T>,\n  fn: (value: T, span: { start: number; end: number }) => U\n): Combinator<U> {\n  return {\n    _tag: 'transform',\n    _meta: parser._meta,\n    _def: { tag: 'transform', parser: parser 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 = parser.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>(parser: Combinator<T>): Combinator<T> {\n  return {\n    _tag: parser._tag,\n    _meta: { ...parser._meta, isTrivia: true },\n    _def: { tag: 'trivia', parser: parser as Combinator<unknown> },\n    parse: parser.parse.bind(parser),\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset\u2192line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { buildLineIndex, annotateSpan } from '../compiler/line-index.ts'\n\nexport type ParseOptions = {\n  trivia?: Combinator<unknown>\n  trackLines?: boolean\n}\n\nexport function grammar<T>(opts: ParseOptions, root: Combinator<T>): Combinator<T> {\n  return {\n    _tag: 'grammar',\n    _meta: root._meta,\n    _def: {\n      tag: 'grammar',\n      parser: root as Combinator<unknown>,\n      triviaParser: opts.trivia,\n      trackLines: opts.trackLines ?? false,\n    },\n    parse(input: string, pos: number, _ctx: ParseContext): ParseResult<T> {\n      const trackLines = opts.trackLines ?? false\n      const ctx: ParseContext = opts.trivia !== undefined\n        ? { trivia: opts.trivia, trackLines }\n        : { trackLines }\n      const result = root.parse(input, pos, ctx)\n      if (trackLines) {\n        const idx = buildLineIndex(input)\n        return { ...result, span: annotateSpan(result.span, idx) }\n      }\n      return result\n    },\n  }\n}\n\nexport function parse<T>(\n  parser: Combinator<T>,\n  input: string,\n  opts: ParseOptions = {}\n): ParseResult<T> {\n  const trackLines = opts.trackLines ?? false\n  const ctx: ParseContext = opts.trivia !== undefined\n    ? { trivia: opts.trivia, trackLines }\n    : { trackLines }\n  const result = parser.parse(input, 0, ctx)\n  if (trackLines) {\n    const idx = buildLineIndex(input)\n    return { ...result, span: annotateSpan(result.span, idx) }\n  }\n  return result\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 * (many loops, non-disjoint choice arms) wrap inner code in IIFEs so\n * early-return keeps working uniformly throughout.\n */\nimport type { Combinator, ParserDef, FirstSet, ParseResult, ParseContext, ChoiceStrategy } from '../types.ts'\nimport { getCoreLiteralValue, getCoreRegexDef } from '../combinators/choice.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  /** Map functions that need to be captured at compile time */\n  mapFns: Array<(v: unknown, span: { start: number; end: number }) => unknown>\n  /** Runtime parser fallbacks (for unknown/_def-less parsers) */\n  runtimeParsers: Array<Combinator<unknown>>\n  /** Whether any case-insensitive lit was emitted (needs collator) */\n  needsCollator: boolean\n  /** Lazy/ref parsers and trivia helpers: parser identity \u2192 generated function name */\n  namedParsers: Map<Combinator<unknown>, string>\n  /** Generated function declaration strings, prepended before the main body */\n  namedFnDecls: string[]\n  /** Active trivia parser (set by grammar() wrappers, cleared on exit) */\n  activeTrivia?: Combinator<unknown>\n}\n\nfunction v(ctx: Ctx, prefix = '_v'): string { return `${prefix}${ctx.vars++}` }\nfunction ind(ctx: Ctx): string { return '  '.repeat(ctx.indent) }\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 failStmt(ctx: Ctx, expected: string, posExpr: string): string {\n  return `${ind(ctx)}return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction firstSetCond(codeVar: string, fs: FirstSet): string {\n  if (fs.kind === 'any') return 'true'\n  if (fs.kind === 'empty') return 'false'\n  return fs.ranges.map(r =>\n    r.lo === r.hi\n      ? `${codeVar} === ${r.lo}`\n      : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`\n  ).join(' || ')\n}\n\n/** Wrap stmts + success return in an IIFE. Returns the IIFE expression string. */\nfunction asIIFE(stmts: string[], valueVar: string, endVar: string, startPos: string, indent: string): string {\n  return [\n    `(() => {`,\n    ...stmts,\n    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,\n    `${indent}})()`,\n  ].join('\\n')\n}\n\n// ---------------------------------------------------------------------------\n// 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      `${ind(ctx)}if (${pos} + ${len} > input.length) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\n      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,\n      `${ind(ctx)}if (_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\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      `${ind(ctx)}if (${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\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      `${ind(ctx)}if (${pos} + ${len} > input.length || ${checks}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\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      `${ind(ctx)}if (!input.startsWith(${JSON.stringify(value)}, ${pos})) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  }\n\n  return { stmts, valueVar: vv, endVar: len === 0 ? pos : `${pos} + ${len}` }\n}\n\nfunction emitRegex(def: Extract<ParserDef, { tag: 'regex' }>, ctx: Ctx, pos: string): ER {\n  const flags = 'y' + def.flags.replace(/[gy]/g, '')\n  const rName = `_re${ctx.regexDecls.length}`\n  ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`)\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(`/${def.source}/`)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  return { stmts, valueVar: vv, endVar: `${pos} + ${vv}.length` }\n}\n\n/**\n * Ensure the active trivia parser has a compiled named function, then return its name.\n * Uses namedParsers so the trivia function is compiled at most once per compile() call.\n * Mirrors the registration pattern in emitLazy.\n */\nfunction ensureTriviaFn(ctx: Ctx): string {\n  const trivia = ctx.activeTrivia!\n  if (!ctx.namedParsers.has(trivia)) {\n    const fnName = `_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(trivia, fnName)   // register FIRST to break any cycles\n    const savedIndent = ctx.indent\n    ctx.indent = 1\n    const r = emit(trivia, ctx, '_pos')\n    ctx.indent = savedIndent\n    ctx.namedFnDecls.push([\n      `function ${fnName}(input, _pos, _ctx) {`,\n      ...r.stmts,\n      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n      `}`,\n    ].join('\\n'))\n  }\n  return ctx.namedParsers.get(trivia)!\n}\n\nfunction emitSeq(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER {\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    // Mirror interpreter sequence.ts:27 \u2014 skip trivia before each item except the first.\n    if (i > 0 && ctx.activeTrivia) {\n      const trivFn = ensureTriviaFn(ctx)\n      const tmp = v(ctx, '_trv')\n      stmts.push(\n        `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,\n        `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`,\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  const arrV = v(ctx, '_arr')\n  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(', ')}]`)\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = JSON.stringify(\n    def.parsers.map(p => {\n      const d = p._def\n      if (d.tag === 'literal') return JSON.stringify(d.value)\n      if (d.tag === 'regex') return `/${d.source}/`\n      return p._tag\n    })\n  )\n\n  // \u2500\u2500 Disjoint: O(1) first-char dispatch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  if (def.disjoint) {\n    const codeV = v(ctx, '_code')\n    const valV = v(ctx, '_chv')\n    const endV = v(ctx, '_che')\n    const stmts: string[] = [\n      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`,\n    ]\n\n    let first = true\n    for (const p of def.parsers) {\n      const cond = firstSetCond(codeV, p._meta.firstSet)\n      const kw = first ? 'if' : 'else if'\n      first = false\n      stmts.push(`${ind(ctx)}${kw} (${cond}) {`)\n      ctx.indent++\n      const r = emit(p, ctx, pos)\n      stmts.push(...r.stmts)\n      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}; ${endV} = ${r.endVar}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n    }\n    stmts.push(\n      `${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,\n    )\n    return { stmts, valueVar: valV, endVar: endV }\n  }\n\n  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 greedyClassify: run the super-regex once, classify by string equality \u2500\u2500\u2500\u2500\n// Single regex exec + O(n_literals) string comparisons. Zero backtracking.\nfunction emitGreedyClassify(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  superIndex: number,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const superParser = def.parsers[superIndex]!\n  const regexDef = getCoreRegexDef(superParser)!\n\n  // Hoist the regex (same mechanism as emitRegex)\n  const reIdx = ctx.regexDecls.length\n  const reVar = `_re${reIdx}`\n  const cleanFlags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n  ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`)\n\n  const matchV = v(ctx, '_gm')\n  const wordV  = v(ctx, '_gw')\n  const endV   = v(ctx, '_ge')\n\n  const stmts: string[] = [\n    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,\n    `${ind(ctx)}if (${matchV} === null) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,\n    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,\n    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,\n  ]\n\n  // For each literal arm: if word === literal, apply its transform chain and return\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    stmts.push(`${ind(ctx)}if (${wordV} === ${JSON.stringify(litVal)}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx)\n    stmts.push(...tR.stmts)\n    stmts.push(`${ind(ctx)}return { ok: true, value: ${tR.valueVar}, span: { start: ${pos}, end: ${endV} } }`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n\n  // Regex arm: apply its transform chain to the matched word\n  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx)\n  stmts.push(...rR.stmts)\n  return { stmts, valueVar: rR.valueVar, 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    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), `${pos} + ${litLen}`, pos, ctx)\n    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}; ${endV} = ${pos} + ${litLen}`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n  stmts.push(`${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${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\nfunction emitFirstMatch(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const resV = v(ctx, '_cr')\n  const stmts: string[] = [`${ind(ctx)}let ${resV}`]\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    const savedIndent = ctx.indent\n    ctx.indent = 0\n    const r = emit(p, ctx, pos)\n    ctx.indent = savedIndent\n    const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx))\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.user)`\n    }\n    const skipCond = gateCond ? `!${resV}?.ok && ${gateCond}` : `!${resV}?.ok`\n\n    if (autoNot && autoNot.length > 0) {\n      const tmp = v(ctx, '_ct')\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)}, ${tmp}.span.end)`\n      ).join(' || ')\n      stmts.push(\n        `${ind(ctx)}if (${skipCond}) { const ${tmp} = (() => { try { return ${iife} } catch {} })(); if (${tmp}?.ok) { const ${anCode} = ${tmp}.span.end < input.length ? input.charCodeAt(${tmp}.span.end) : -1; if (!(${rejectCond})) ${resV} = ${tmp} } }`,\n      )\n    } else {\n      stmts.push(`${ind(ctx)}if (${skipCond}) { try { ${resV} = ${iife} } catch {} }`)\n    }\n  }\n  stmts.push(\n    `${ind(ctx)}if (!${resV}?.ok) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,\n  )\n  return { stmts, valueVar: `${resV}.value`, endVar: `${resV}.span.end` }\n}\n\nfunction emitNonDisjoint(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  strategy: ChoiceStrategy,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  if (strategy.tag === 'greedyClassify')\n    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 helpers for emitGreedyClassify / emitLiteralsLongestFirst \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Apply transform chain only \u2014 no parsing, value already known. */\nfunction emitTransformChain(p: Combinator<unknown>, baseValue: string, endV: string, startPos: string, ctx: Ctx): ER {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx)\n    const fnIdx = ctx.mapFns.length\n    ctx.mapFns.push(def.fn)\n    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  const emitInnerIIFE = (): string => {\n    const savedIndent = ctx.indent\n    ctx.indent = 0\n    const r = emit(def.parser, ctx, curV)\n    ctx.indent = savedIndent\n    return asIIFE(r.stmts, r.valueVar, r.endVar, curV, ind(ctx) + '  ')\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  stmts.push(\n    `${ind(ctx)}const _iter = (() => { try { return ${emitInnerIIFE()} } catch { return null } })()`,\n    `${ind(ctx)}if (!_iter?.ok || _iter.span.end === ${curV}) break`,\n    `${ind(ctx)}${arrV}.push(_iter.value)`,\n    `${ind(ctx)}${curV} = _iter.span.end`,\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 savedIndent = ctx.indent\n  ctx.indent = 0\n  const r = emit(def.parser, ctx, pos)\n  ctx.indent = savedIndent\n\n  const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx))\n  const resV = v(ctx, '_optr')\n  const stmts = [\n    `${ind(ctx)}const ${resV} = (() => { try { return ${iife} } catch { return null } })()`,\n    `${ind(ctx)}const ${valV} = ${resV}?.ok ? ${resV}.value : null`,\n    `${ind(ctx)}const ${endV} = ${resV}?.ok ? ${resV}.span.end : ${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  // IIFE helpers \u2014 inner emit at indent 0 to avoid nested indentation noise\n  const iife = (inner: Combinator<unknown>, posExpr: string): string => {\n    const saved = ctx.indent\n    ctx.indent = 0\n    const r = emit(inner, ctx, posExpr)\n    ctx.indent = saved\n    return asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx))\n  }\n\n  const firstR_saved = ctx.indent\n  ctx.indent = 0\n  const firstR = emit(def.parser, ctx, pos)\n  ctx.indent = firstR_saved\n\n  const firstV = v(ctx, '_sb0')\n  const sepV = v(ctx, '_sbs')\n  const nextV = v(ctx, '_sbn')\n\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    `${ind(ctx)}const ${firstV} = (() => { try { return ${asIIFE(firstR.stmts, firstR.valueVar, firstR.endVar, pos, ind(ctx))} } catch { return null } })()`,\n    `${ind(ctx)}if (${firstV}?.ok) {`,\n  ]\n  ctx.indent++\n  stmts.push(\n    `${ind(ctx)}${arrV}.push(${firstV}.value)`,\n    `${ind(ctx)}${curV} = ${firstV}.span.end`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  )\n  ctx.indent++\n  stmts.push(\n    `${ind(ctx)}const ${sepV} = (() => { try { return ${iife(def.separator, curV)} } catch { return null } })()`,\n    `${ind(ctx)}if (!${sepV}?.ok) break`,\n    `${ind(ctx)}const ${nextV} = (() => { try { return ${iife(def.parser, `${sepV}.span.end`)} } catch { return null } })()`,\n    `${ind(ctx)}if (!${nextV}?.ok) break`,\n    `${ind(ctx)}${arrV}.push(${nextV}.value)`,\n    `${ind(ctx)}${curV} = ${nextV}.span.end`,\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  // Helper: emit parser as a safe IIFE expression that returns result|null\n  const safeIIFE = (inner: Combinator<unknown>, posExpr: string): string => {\n    const saved = ctx.indent\n    ctx.indent = 0\n    const r = emit(inner, ctx, posExpr)\n    ctx.indent = saved\n    return `(() => { try { return ${asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx))} } catch { return null } })()`\n  }\n\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\n  const sentV = v(ctx, '_sts')\n  stmts.push(\n    `${ind(ctx)}const ${sentV} = ${safeIIFE(def.sentinel, curV)}`,\n    `${ind(ctx)}if (${sentV}?.ok) { ${foundV} = true; break }`,\n  )\n\n  // Skippers \u2014 each wrapped so a failed/throwing skip 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 skV = v(ctx, '_sk')\n      stmts.push(\n        `${ind(ctx)}if (!${advV}) { const ${skV} = ${safeIIFE(skipper, curV)}; if (${skV}?.ok && ${skV}.span.end > ${curV}) { ${curV} = ${skV}.span.end; ${advV} = true } }`,\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(\n      `${ind(ctx)}if (!${foundV}) return { ok: false, expected: ${expectedStr}, span: { start: ${pos}, end: ${curV} } }`,\n    )\n  }\n\n  const valV = v(ctx)\n  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`)\n  return { stmts, valueVar: valV, endVar: curV }\n}\n\nfunction emitRuntimeFallback(parser: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const idx = ctx.runtimeParsers.length\n  ctx.runtimeParsers.push(parser)\n  const rv = v(ctx, '_rt')\n  const vv = v(ctx, '_rtv')\n  const ev = v(ctx, '_rte')\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    `${ind(ctx)}if (!${rv}.ok) return ${rv}`,\n    `${ind(ctx)}const ${vv} = ${rv}.value`,\n    `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n  ]\n  return { stmts, valueVar: vv, endVar: ev }\n}\n\n/**\n * Compile a lazy/ref parser into a named function declaration.\n *\n * The named function is registered in ctx.namedParsers BEFORE its body is\n * emitted. This breaks the recursion cycle: when the body emitter encounters\n * the same ref again it finds it already registered and emits a call instead\n * of recursing infinitely.\n *\n * All named functions share the parent function's scope (via closure), so they\n * can read _rp, _mf, and all hoisted regex consts without extra args.\n *\n * JavaScript hoists function declarations within a function body, so the order\n * we push to namedFnDecls doesn't affect correctness.\n */\nfunction emitLazy(p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'lazy' }>, ctx: Ctx, pos: string): ER {\n  if (!ctx.namedParsers.has(p)) {\n    const fnName = `_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST so recursive refs see it\n\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      // ref.define() not called yet \u2014 fall back to runtime\n      ctx.namedParsers.delete(p)\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n\n    const savedIndent = ctx.indent\n    ctx.indent = 1\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent = savedIndent\n\n    ctx.namedFnDecls.push([\n      `function ${fnName}(input, _pos, _ctx) {`,\n      ...r.stmts,\n      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n      `}`,\n    ].join('\\n'))\n  }\n\n  const fnName = ctx.namedParsers.get(p)!\n  const rv = v(ctx, '_pfr')\n  const vv = v(ctx, '_pfv')\n  const ev = v(ctx, '_pfe')\n  return {\n    stmts: [\n      `${ind(ctx)}const ${rv} = ${fnName}(input, ${pos}, _ctx)`,\n      `${ind(ctx)}if (!${rv}.ok) return ${rv}`,\n      `${ind(ctx)}const ${vv} = ${rv}.value`,\n      `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n    ],\n    valueVar: vv,\n    endVar: ev,\n  }\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 '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 inner = emit(def.parser, ctx, pos)\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.fn)\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          ...skipR.stmts.map(s => '  ' + s),\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 'grammar': {\n      // Propagate trivia from the grammar opts into ctx so emitSeq can skip it.\n      const savedTrivia = ctx.activeTrivia\n      if (def.triviaParser) ctx.activeTrivia = def.triviaParser\n      const r = emit(def.parser, ctx, pos)\n      if (savedTrivia === undefined) delete ctx.activeTrivia\n      else ctx.activeTrivia = savedTrivia\n      return r\n    }\n    case 'scanTo': return emitScanTo(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          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.user)) ${failStmt({ ...ctx, indent: 0 }, '\"gate\"', pos).trim()}`,\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        ctx.indent = 1\n        const innerR = emit(innerParser, ctx, '_pos')\n        ctx.indent = savedIndent\n        ctx.namedFnDecls.push([\n          `function ${fnName}(input, _pos, _ctx) {`,\n          ...innerR.stmts,\n          `  return { ok: true, value: ${innerR.valueVar}, span: { start: _pos, end: ${innerR.endVar} } }`,\n          `}`,\n        ].join('\\n'))\n      }\n      const fn = ctx.namedParsers.get(innerParser)!\n\n      const rv = v(ctx, '_wcr')\n      const vv = v(ctx)\n      const ev = v(ctx, '_wce')\n      return {\n        stmts: [\n          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, user: _mf[${evIdx}]() })`,\n          `${ind(ctx)}if (!${rv}.ok) return ${rv}`,\n          `${ind(ctx)}const ${vv} = ${rv}.value`,\n          `${ind(ctx)}const ${ev} = ${rv}.span.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  /** 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\nexport function compile<T>(parser: Combinator<T>): CompiledParser<T> {\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    mapFns: [],\n    runtimeParsers: [],\n    needsCollator: false,\n    namedParsers: new Map(),\n    namedFnDecls: [],\n  }\n\n  const r = emit(parser 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 source = [\n    ...ctx.regexDecls,\n    '',\n    ...ctx.namedFnDecls,\n    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _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', '_ctx', [\n    ...ctx.regexDecls,\n    collatorDecl,\n    ...ctx.namedFnDecls,\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    ctx: ParseContext,\n  ) => ParseResult<T>\n\n  const defaultCtx: ParseContext = { trackLines: false }\n\n  // Build an inline expression only when there are no runtime fallbacks or\n  // map-function closures that can't be serialized.\n  const canInline = ctx.runtimeParsers.length === 0 && ctx.mapFns.length === 0\n  const inlineExpression: string | null = canInline ? buildInlineExpression(ctx, r, collatorDecl) : 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, defaultCtx)\n    },\n  }\n}\n\nfunction buildInlineExpression(\n  ctx: Ctx,\n  r: ER,\n  collatorDecl: string,\n): string {\n  const bodyLines = [\n    `  let pos = _pos`,\n    ...r.stmts.map(s => `  ${s}`),\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  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0\n  if (!needsWrapper) {\n    return innerFn\n  }\n\n  // Wrap in IIFE to hoist regex/collator declarations and named recursive functions.\n  // Named functions declared here close over _re* consts and can call each other\n  // freely \u2014 JS hoists function declarations within the IIFE scope.\n  return [\n    `/* @__PURE__ */ (() => {`,\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    collatorDecl ? `  ${collatorDecl.trim()}` : '',\n    ...ctx.namedFnDecls.flatMap(f => f.split('\\n').map(l => `  ${l}`)),\n    `  return ${innerFn}`,\n    `})()`,\n  ].filter(Boolean).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.user`. 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: (user: 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.user))\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 `parser` with `ctx.user` 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, parser: Combinator<T>): Combinator<T> {\n  const meta: ParserMeta = {\n    firstSet: parser._meta.firstSet,\n    canMatchNewline: parser._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'withCtx',\n    _meta: meta,\n    _def: { tag: 'withCtx', extra, parser: parser as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      return parser.parse(input, pos, { ...ctx, user: extra })\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\n\nexport type { ParseError }\n\n/**\n * Error-recovery combinator. Tries `parser`; 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  parser: Combinator<T>,\n  sentinel: Combinator<unknown>,\n): Combinator<T | ParseError> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'recover',\n    _meta: meta,\n    _def: { tag: 'recover', parser: parser as Combinator<unknown>, sentinel },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = parser.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n\n      let scanPos = pos\n      while (scanPos < input.length) {\n        if (sentinel.parse(input, scanPos, ctx).ok) break\n        scanPos++\n      }\n\n      const error: ParseError = {\n        _tag: 'parseError',\n        span: { start: pos, end: scanPos },\n        expected: result.expected,\n      }\n      return { ok: true, value: error, span: { start: pos, end: scanPos } }\n    },\n  }\n}\n\nexport function isParseError(value: unknown): value is ParseError {\n  return typeof value === 'object' && value !== null && (value as ParseError)._tag === 'parseError'\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { literal } from './literal.ts'\nimport { sequence } from './sequence.ts'\nimport { transform } from './map.ts'\nimport { any } from './first-set.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      while (cur < input.length) {\n        // Check sentinel \u2014 if it matches here, stop and return consumed text.\n        const s = sentinel.parse(input, cur, ctx)\n        if (s.ok) {\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, ctx)\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        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  const inner = scanTo(literal(close), options)\n  return transform(\n    sequence(literal(open), inner, literal(close)),\n    ([o, content, c]) => o + content + c,\n  )\n}\n", "import type { ParseContext, ParseFail } from '../types.ts'\nimport type { Parser, RuleKeys } from './grammar.ts'\nimport type { CSTLeaf, CSTError, NodeLike } from './types.ts'\n\n// ---------------------------------------------------------------------------\n// ParseDoc\n// ---------------------------------------------------------------------------\n\n/**\n * The result of Parser.parse() \u2014 holds the current tree and supports\n * incremental re-parsing via edit().\n *\n *   const doc = css.parse('Stylesheet', src)\n *   doc.tree    // CSTNode (or your N), null if parse failed\n *   doc.errors  // ParseFail[], empty on success\n *   doc.input   // the source string that produced this tree\n *\n *   const doc2 = doc.edit(newSrc, changeStart, changeEnd)\n */\nexport interface ParseDoc<N extends NodeLike = NodeLike> {\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n  /**\n   * Incrementally re-parse after a text change.\n   *\n   * @param changeStart  Byte offset where the change begins (same in old and new text).\n   * @param oldChangeEnd Byte offset where the replaced region ends in the OLD text (exclusive).\n   * @param newText      The replacement text (may be empty for a pure deletion).\n   *\n   * Maps directly to editor change events:\n   *   VSCode:     doc.edit(change.rangeOffset, change.rangeOffset + change.rangeLength, change.text)\n   *   CodeMirror: doc.edit(change.from, change.to, change.insert)\n   *   LSP:        doc.edit(startByte, endByte, change.text)  // after line/col \u2192 byte conversion\n   */\n  edit(changeStart: number, oldChangeEnd: number, newText: string): ParseDoc<N>\n}\n\n// ---------------------------------------------------------------------------\n// Tree navigation helpers\n// ---------------------------------------------------------------------------\n\ntype FoundNode = { node: NodeLike; 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(node: NodeLike, pos: number, path: number[] = []): FoundNode | 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      return findContaining(child, pos, [...path, i]) ?? { node: child, path: [...path, i] }\n    }\n  }\n  return null\n}\n\nfunction ancestorsAt(root: NodeLike, path: number[]): NodeLike[] {\n  const ancestors: NodeLike[] = [root]\n  let cur: NodeLike = 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)\n    cur = child\n  }\n  return ancestors\n}\n\ntype Rebuilder<N extends NodeLike> = {\n  rebuild(node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>): N\n}\n\nfunction replaceAtPath<N extends NodeLike>(\n  grammar: Rebuilder<N>,\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 unknown[] as Array<N | CSTLeaf | CSTError>\n  newChildren[idx] = rest.length === 0\n    ? newNode\n    : replaceAtPath(grammar, root.children[idx] as N, rest, newNode)\n  return grammar.rebuild(root, newChildren)\n}\n\n// ---------------------------------------------------------------------------\n// ParseDoc implementation\n// ---------------------------------------------------------------------------\n\nclass ParseDocImpl<N extends NodeLike> implements ParseDoc<N> {\n  private readonly _parser: Parser<N>\n  private readonly _ruleName: string\n  readonly tree: N | null\n  readonly errors: ParseFail[]\n  readonly input: string\n\n  constructor(parser: Parser<N>, ruleName: string, tree: N | null, errors: ParseFail[], input: string) {\n    this._parser   = parser\n    this._ruleName = ruleName\n    this.tree      = tree\n    this.errors    = errors\n    this.input     = input\n  }\n\n  edit(changeStart: number, oldChangeEnd: number, newText: string): ParseDoc<N> {\n    const newInput = this.input.slice(0, changeStart) + newText + this.input.slice(oldChangeEnd)\n\n    if (!this.tree) return makeParseDoc(this._parser, this._ruleName, newInput)\n\n    const delta = newText.length - (oldChangeEnd - changeStart)\n    const found = findContaining(this.tree, changeStart)\n    if (!found) return makeParseDoc(this._parser, this._ruleName, newInput)\n\n    const ancestors = ancestorsAt(this.tree, found.path)\n    const candidates: FoundNode[] = [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    for (const candidate of candidates) {\n      const { node, path } = candidate\n      const expectedEnd = node.span.end + delta\n      const parser = this._parser.rule(node.type as RuleKeys<typeof this._parser>)\n      const ctx: ParseContext = { trackLines: false, user: node.savedContext }\n      const r = parser.parse(newInput, node.span.start, ctx)\n      if (!r.ok) continue\n      if (r.span.end === expectedEnd) {\n        const newTree = replaceAtPath(this._parser, this.tree!, path, r.value)\n        return new ParseDocImpl(this._parser, this._ruleName, newTree, [], newInput)\n      }\n    }\n\n    return makeParseDoc(this._parser, this._ruleName, newInput)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\nexport function makeParseDoc<N extends NodeLike>(\n  parser: Parser<N>,\n  ruleName: string,\n  input: string,\n): ParseDoc<N> {\n  const ctx: ParseContext = { trackLines: false }\n  const r = parser.rule(ruleName as RuleKeys<typeof parser>).parse(input, 0, ctx)\n  if (r.ok) {\n    return new ParseDocImpl(parser, ruleName, r.value, [], input)\n  }\n  return new ParseDocImpl(parser, ruleName, null, [{ ok: false, expected: r.expected, span: r.span }], input)\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, Span } from '../types.ts'\nimport { ref } from '../combinators/ref.ts'\nimport type { CSTNode, CSTLeaf, CSTError, CSTTrivia, CSTRawChild, NodeLike } from './types.ts'\nimport { makeParseDoc } from './incremental.ts'\nimport type { ParseDoc } from './incremental.ts'\n\n// ---------------------------------------------------------------------------\n// TypeScript helpers\n// ---------------------------------------------------------------------------\n\ntype Capital = 'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'\n             | 'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z'\n\n/** Keys of T whose names start with a capital letter (CST parser). */\nexport type RuleKeys<T> = {\n  [K in keyof T & string]: K extends `${Capital}${string}` ? K : never\n}[keyof T & string]\n\n/**\n * Maps each grammar property to its resolved Combinator type.\n *\n * Use as the parameter type in rule thunks \u2014 gives `g.*` the correct\n * Combinator type instead of the raw function type:\n *\n *   Expr = (g: Refs<this>) => choice(g.Atom, sequence(g.Expr, literal('+'), g.Atom))\n */\nexport type Refs<T> = {\n  [K in keyof T as K extends `_${string}` ? never\n    : T[K] extends Combinator<any> ? K\n    : T[K] extends (g: any) => Combinator<any> ? K\n    : never\n  ]: T[K] extends Combinator<infer V> ? Combinator<V>\n   : T[K] extends (g: any) => Combinator<infer V> ? Combinator<V>\n   : never\n}\n\n// ---------------------------------------------------------------------------\n// Parser base class\n// ---------------------------------------------------------------------------\n\n/**\n * Base class for grammars that automatically produce a CST (or a custom AST\n * if you override `buildNode`).\n *\n * Rules are declared as class properties:\n *   - Plain Combinator  (no cross-references needed):\n *       digits = regex(/[0-9]+/)\n *   - Thunk  (references other parser via `g`):\n *       Expr = (g: Refs<this>) => choice(g.Atom, sequence(g.Expr, literal('+')))\n *\n * Convention:\n *   Capital letter \u2192 CSTNode-producing rule (span + savedContext + children)\n *   lowercase      \u2192 transparent helper (terminals bubble up as CSTLeaf in the\n *                    nearest enclosing capital rule)\n *\n * Mutual recursion works because thunks are collected first, ref() placeholders\n * installed for each one, then all thunks are called with `g` (a map of refs).\n * Initialization is lazy \u2014 triggered on the first call to rule().\n *\n * Grammar inheritance: subclass property initializers naturally override parent\n * ones (they run last in construction order), so extending a grammar means only\n * re-declaring the parser you want to change.\n *\n *   class JSONCParser extends JSONParser {\n *     ws = jsoncWs  // override just this one rule\n *   }\n */\nexport class Parser<N extends NodeLike = CSTNode> {\n  private _built = false\n\n  private _build() {\n    if (this._built) return\n    this._built = true\n\n    // All own enumerable properties are set by the time this runs (called from\n    // rule() after construction completes, so subclass initializers have fired).\n    const keys = Object.keys(this).filter(k => !k.startsWith('_'))\n\n    type Slot = ReturnType<typeof ref<unknown>>\n    const slots = new Map<string, Slot>()\n    const g: Record<string, unknown> = {}\n\n    // Phase 1: separate plain Combinators from thunks.\n    // Plain Combinators go directly into g (capital ones wrapped first).\n    // Thunks get a ref() slot in g so mutual references resolve lazily.\n    for (const key of keys) {\n      const val = (this as unknown as Record<string, unknown>)[key]\n      if (isCombinator(val)) {\n        const isRule = /^[A-Z]/.test(key)\n        const final = isRule ? this._makeNodeParser(key, val as Combinator<unknown>) : val as Combinator<unknown>\n        g[key] = final\n        Object.defineProperty(this, key, { value: final, writable: false, configurable: false })\n      } else if (typeof val === 'function') {\n        const slot = ref<unknown>()\n        slots.set(key, slot)\n        g[key] = slot\n      }\n    }\n\n    // Phase 2: call thunks with g, wrap capitals, define their slots.\n    for (const [key, slot] of slots) {\n      const thunk = (this as unknown as Record<string, unknown>)[key] as (g: unknown) => Combinator<unknown>\n      const inner = thunk(g)\n      const isRule = /^[A-Z]/.test(key)\n      const final = isRule ? this._makeNodeParser(key, inner) : inner\n      slot.define(final)\n      // Propagate first-set so choices wrapping this ref dispatch correctly.\n      slot._meta.firstSet        = final._meta.firstSet\n      slot._meta.canMatchNewline = final._meta.canMatchNewline\n      Object.defineProperty(this, key, { value: final, writable: false, configurable: false })\n    }\n  }\n\n  /**\n   * Override to produce a custom AST node instead of a plain CSTNode.\n   * The returned object must satisfy NodeLike for IncrementalParser to work.\n   *\n   * `rawChildren` is `children` plus any trivia tokens (whitespace/comments)\n   * consumed between terms, in parse order. Use it to inspect trivia when the\n   * grammar is whitespace-sensitive (e.g. CSS descendant vs adjacent combinators).\n   * The default implementation ignores `rawChildren`.\n   */\n  protected buildNode(\n    type: string,\n    span: Span,\n    children: ReadonlyArray<N | CSTLeaf | CSTError>,\n    savedContext: unknown,\n    _rawChildren: ReadonlyArray<CSTRawChild>,\n  ): N {\n    return { _tag: 'node', type, span, children: children as CSTNode['children'], savedContext } as unknown as N\n  }\n\n  /** Wrap an inner combinator so it produces a CSTNode on each match. */\n  private _makeNodeParser(type: string, inner: Combinator<unknown>): Combinator<N> {\n    const self = this\n    const meta: ParserMeta = {\n      firstSet:        inner._meta.firstSet,\n      canMatchNewline: inner._meta.canMatchNewline,\n      isTrivia:        false,\n    }\n    return {\n      _tag: 'cstNode',\n      _meta: meta,\n      _def:  { tag: 'unknown' },\n      parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n        const savedContext = ctx.user !== undefined\n          ? Object.assign({}, ctx.user as Record<string, unknown>)\n          : undefined\n\n        const children: (N | CSTLeaf | CSTError)[] = []\n        const rawChildren: CSTRawChild[] = []\n        const innerCtx: ParseContext = {\n          ...ctx,\n          _cstChildren:    children as unknown[],\n          _cstLeaves:      children as unknown[],\n          _cstRawChildren: rawChildren as unknown[],\n        }\n\n        const r = inner.parse(input, pos, innerCtx)\n        if (!r.ok) return r\n\n        const node = self.buildNode(type, r.span, children, savedContext, rawChildren)\n        if (ctx._cstChildren)    (ctx._cstChildren as unknown[]).push(node)\n        if (ctx._cstRawChildren) (ctx._cstRawChildren as unknown[]).push(node)\n        return { ok: true, value: node, span: r.span }\n      },\n    }\n  }\n\n  /** Reconstruct a node with a new children array (used by IncrementalParser). */\n  rebuild(node: N, newChildren: ReadonlyArray<N | CSTLeaf | CSTError>): N {\n    return this.buildNode(node.type, node.span, newChildren, node.savedContext, [])\n  }\n\n  /**\n   * Parse input starting from a named rule, returning a ParseDoc.\n   * The doc carries the tree, any parse errors, and an edit() method\n   * for incremental re-parsing on subsequent changes.\n   *\n   *   const doc = css.parse('Stylesheet', src)\n   *   doc.tree    // the CST root, or null on failure\n   *   doc.errors  // ParseFail[], empty on success\n   *\n   *   // In an editor \u2014 just keep calling edit():\n   *   const doc2 = doc.edit(newSrc, changeStart, changeEnd)\n   */\n  parse(ruleName: RuleKeys<this>, input: string): ParseDoc<N> {\n    return makeParseDoc(this, ruleName as string, input)\n  }\n\n  /**\n   * Get the compiled Combinator for a named rule.\n   * Triggers lazy initialization on first call.\n   */\n  rule(name: RuleKeys<this>): Combinator<N> {\n    this._build()\n    const p = (this as unknown as Record<string, unknown>)[name as string]\n    if (!p) throw new Error(`No rule '${String(name)}' on this parser`)\n    return p as Combinator<N>\n  }\n}\n\nfunction isCombinator(val: unknown): boolean {\n  return val !== null && typeof val === 'object' && '_tag' in (val as object)\n}\n"],
+  "mappings": "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",
+  "names": ["parser", "parser", "parser", "parser", "parser", "parser", "trivia", "parser", "fnName", "parser", "parser", "skip", "parser"]
+}

package/dist/plugin/evaluator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Statically evaluates parseman combinator call expressions from an oxc AST
+ * into actual Combinator<unknown> objects by calling the real library functions.
+ *
+ * Returns null for anything unresolvable (user closures, external variables,
+ * template literals, computed keys, etc.) — callers leave those as-is.
+ */
+import type { Expression, Node } from '@oxc-project/types';
+import type { Combinator } from '../types.ts';
+export type Scope = Map<string, Combinator<unknown>>;
+/** Try to evaluate an oxc AST Expression as a parseman Combinator. Returns null if impossible. */
+export declare function evaluateExpr(node: Expression, scope: Scope): Combinator<unknown> | null;
+/** Check if an AST node references any name from the given set (used to detect parseman usage). */
+export declare function referencesAny(node: Node, names: Set<string>, scope: Scope): boolean;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/plugin/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/plugin/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,MAAM,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAA;AAcpD,kGAAkG;AAClG,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAsBvF;AAoCD,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAcnF"}