parseman 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1795 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Parser: () => Parser,
+  annotateSpan: () => annotateSpan,
+  balanced: () => balanced,
+  buildLineIndex: () => buildLineIndex,
+  choice: () => choice,
+  compile: () => compile,
+  guard: () => guard,
+  isParseError: () => isParseError,
+  literal: () => literal,
+  many: () => many,
+  not: () => not,
+  offsetToLineCol: () => offsetToLineCol,
+  oneOrMore: () => oneOrMore,
+  optional: () => optional,
+  parse: () => parse,
+  parser: () => parser,
+  recover: () => recover,
+  ref: () => ref,
+  regex: () => regex,
+  scanTo: () => scanTo,
+  sepBy: () => sepBy,
+  sequence: () => sequence,
+  skip: () => skip,
+  transform: () => transform,
+  trivia: () => trivia,
+  withCtx: () => withCtx
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/combinators/first-set.ts
+function union(a, b) {
+  if (a.kind === "any" || b.kind === "any") return { kind: "any" };
+  if (a.kind === "empty") return b;
+  if (b.kind === "empty") return a;
+  return { kind: "ranges", ranges: mergeRanges([...a.ranges, ...b.ranges]) };
+}
+function intersects(a, b) {
+  if (a.kind === "any" || b.kind === "any") return true;
+  if (a.kind === "empty" || b.kind === "empty") return false;
+  for (const ra of a.ranges) {
+    for (const rb of b.ranges) {
+      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
+    }
+  }
+  return false;
+}
+function fromChar(code) {
+  return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
+}
+function fromRange(lo, hi) {
+  return { kind: "ranges", ranges: [{ lo, hi }] };
+}
+function any() {
+  return { kind: "any" };
+}
+function empty() {
+  return { kind: "empty" };
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
+  const out = [{ lo: sorted[0].lo, hi: sorted[0].hi }];
+  for (let i = 1; i < sorted.length; i++) {
+    const top = out[out.length - 1];
+    const cur = sorted[i];
+    if (cur.lo <= top.hi + 1) {
+      if (cur.hi > top.hi) top.hi = cur.hi;
+    } else {
+      out.push({ lo: cur.lo, hi: cur.hi });
+    }
+  }
+  return out;
+}
+
+// src/combinators/literal.ts
+var _collatorCache = null;
+function collator() {
+  if (_collatorCache === null) {
+    _collatorCache = new Intl.Collator(void 0, { sensitivity: "accent" });
+  }
+  return _collatorCache;
+}
+function literal(value, opts = {}) {
+  const caseInsensitive = opts.caseInsensitive ?? false;
+  const firstSet = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
+  const meta = {
+    firstSet,
+    canMatchNewline: value.includes("\n"),
+    isTrivia: false
+  };
+  if (caseInsensitive) {
+    const upper = value.toUpperCase();
+    const lower = value.toLowerCase();
+    const firstUpper = upper.codePointAt(0);
+    const firstLower = lower.codePointAt(0);
+    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? { kind: "ranges", ranges: [
+      { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }
+    ] } : firstSet;
+  }
+  return {
+    _tag: "literal",
+    _meta: meta,
+    _def: { tag: "literal", value, caseInsensitive },
+    parse(input, pos, _ctx) {
+      const end = pos + value.length;
+      if (end > input.length) {
+        return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+      }
+      const slice = input.slice(pos, end);
+      const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
+      if (matched) {
+        const span = { start: pos, end };
+        const leaf = { _tag: "leaf", value: slice, span };
+        if (_ctx._cstLeaves) _ctx._cstLeaves.push(leaf);
+        if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(leaf);
+        return { ok: true, value: slice, span };
+      }
+      return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/regex.ts
+var import_regexp_tree = __toESM(require("regexp-tree"), 1);
+function firstSetFromRegex(pattern) {
+  try {
+    const ast = import_regexp_tree.default.parse(`/${pattern}/`);
+    return extractFirstSet(ast.body);
+  } catch {
+    return { firstSet: any(), canMatchNewline: true };
+  }
+}
+function canBeEmpty(node) {
+  if (!node) return true;
+  switch (node.type) {
+    case "Repetition": {
+      const q = node.quantifier;
+      return q.kind === "*" || q.kind === "?" || q.kind === "Range" && (q.from ?? 1) === 0;
+    }
+    case "Alternative": {
+      const exprs = node.expressions;
+      return !exprs || exprs.length === 0 || exprs.every((e) => canBeEmpty(e));
+    }
+    case "Group":
+      return canBeEmpty(node.expression);
+    case "Disjunction":
+      return canBeEmpty(node.left) || canBeEmpty(node.right);
+    default:
+      return false;
+  }
+}
+function extractFirstSet(node) {
+  if (!node) return { firstSet: empty(), canMatchNewline: false };
+  switch (node.type) {
+    case "Disjunction": {
+      const left = extractFirstSet(node.left);
+      const right = extractFirstSet(node.right);
+      return {
+        firstSet: union(left.firstSet, right.firstSet),
+        canMatchNewline: left.canMatchNewline || right.canMatchNewline
+      };
+    }
+    case "Alternative": {
+      const exprs = node.expressions;
+      if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
+      let fs = empty();
+      let canNL = false;
+      for (const expr of exprs) {
+        const r = extractFirstSet(expr);
+        fs = union(fs, r.firstSet);
+        canNL = canNL || r.canMatchNewline;
+        if (!canBeEmpty(expr)) break;
+      }
+      return { firstSet: fs, canMatchNewline: canNL };
+    }
+    case "Char": {
+      const kind = node.kind;
+      if (kind === "simple") {
+        const code = node.codePoint ?? node.value.codePointAt(0) ?? 0;
+        return { firstSet: fromRange(code, code), canMatchNewline: code === 10 };
+      }
+      if (kind === "meta") {
+        const val = node.value;
+        if (val === ".") return { firstSet: any(), canMatchNewline: false };
+        if (val === "d") return { firstSet: fromRange(48, 57), canMatchNewline: false };
+        if (val === "D") return { firstSet: any(), canMatchNewline: true };
+        if (val === "w") return {
+          firstSet: union(
+            union(fromRange(48, 57), fromRange(65, 90)),
+            union(fromRange(97, 122), fromRange(95, 95))
+          ),
+          canMatchNewline: false
+        };
+        if (val === "s") return { firstSet: fromRange(9, 13), canMatchNewline: true };
+        if (val === "n") return { firstSet: fromRange(10, 10), canMatchNewline: true };
+      }
+      return { firstSet: any(), canMatchNewline: true };
+    }
+    case "CharacterClass": {
+      const expressions = node.expressions;
+      let fs = empty();
+      let canNL = false;
+      for (const expr of expressions) {
+        if (expr.type === "ClassRange") {
+          const from = expr.from.codePoint;
+          const to = expr.to.codePoint;
+          fs = union(fs, fromRange(from, to));
+          if (from <= 10 && 10 <= to) canNL = true;
+        } else if (expr.type === "Char") {
+          const r = extractFirstSet(expr);
+          fs = union(fs, r.firstSet);
+          canNL = canNL || r.canMatchNewline;
+        }
+      }
+      if (node.negative) return { firstSet: any(), canMatchNewline: true };
+      return { firstSet: fs, canMatchNewline: canNL };
+    }
+    case "Repetition": {
+      return extractFirstSet(node.expression);
+    }
+    case "Group": {
+      return extractFirstSet(node.expression);
+    }
+    default:
+      return { firstSet: any(), canMatchNewline: true };
+  }
+}
+function optimizeRegex(source, flags) {
+  try {
+    const result = import_regexp_tree.default.optimize(`/${source}/${flags}`);
+    const str = result.toString();
+    const lastSlash = str.lastIndexOf("/");
+    return str.slice(1, lastSlash);
+  } catch {
+    return source;
+  }
+}
+function regex(pattern, flags = "") {
+  const source = typeof pattern === "string" ? pattern : pattern.source;
+  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+  const optimizedSource = optimizeRegex(source, resolvedFlags);
+  const anchored = new RegExp(optimizedSource, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const { firstSet, canMatchNewline } = firstSetFromRegex(source);
+  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  return {
+    _tag: "regex",
+    _meta: meta,
+    _def: { tag: "regex", source, flags: resolvedFlags, optimizedSource },
+    parse(input, pos, ctx) {
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return { ok: false, expected: [`/${source}/`], span: { start: pos, end: pos } };
+      }
+      const span = { start: pos, end: pos + m[0].length };
+      const leaf = { _tag: "leaf", value: m[0], span };
+      if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
+      if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+      return { ok: true, value: m[0], span };
+    }
+  };
+}
+
+// src/combinators/sequence.ts
+function sequence(...parsers) {
+  const meta = {
+    firstSet: parsers[0]?._meta.firstSet ?? empty(),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: { tag: "sequence", parsers },
+    parse(input, pos, ctx) {
+      const values = [];
+      let cur = pos;
+      for (let i = 0; i < parsers.length; i++) {
+        if (ctx.trivia && i > 0) {
+          const tr = ctx.trivia.parse(input, cur, { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user });
+          if (tr.ok) {
+            if (ctx._cstRawChildren && tr.span.end > tr.span.start)
+              ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
+            cur = tr.span.end;
+          }
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        values.push(result.value);
+        cur = result.span.end;
+      }
+      return {
+        ok: true,
+        value: values,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
+}
+
+// src/combinators/choice.ts
+function choice(...args) {
+  const parsers = args.map((a) => "gate" in a ? a.parser : a);
+  const gates = args.map((a) => "gate" in a ? a.gate : null);
+  const hasGates = gates.some((g) => g !== null);
+  const disjoint = !hasGates && areDisjoint(parsers.map((p) => p._meta.firstSet));
+  let combined = { kind: "empty" };
+  for (const p of parsers) combined = union(combined, p._meta.firstSet);
+  const meta = {
+    firstSet: combined,
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false,
+    disjoint
+  };
+  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
+  const autoNot = !disjoint && !hasGates && strategy?.tag === "firstMatch" ? computeAutoNot(parsers) : parsers.map(() => null);
+  let greedyRe = null;
+  let greedyLitMap = null;
+  let sortedParsers = null;
+  if (strategy?.tag === "greedyClassify") {
+    const regexDef = getCoreRegexDef(parsers[strategy.superIndex]);
+    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
+    greedyRe = new RegExp(regexDef.source, flags);
+    greedyLitMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < parsers.length; i++) {
+      if (i === strategy.superIndex) continue;
+      const litVal = getCoreLiteralValue(parsers[i]);
+      if (litVal !== null) greedyLitMap.set(litVal, i);
+    }
+  } else if (strategy?.tag === "literalsLongestFirst") {
+    sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+  }
+  return {
+    _tag: "choice",
+    _meta: meta,
+    _def: {
+      tag: "choice",
+      parsers,
+      gates,
+      disjoint,
+      strategy: strategy ?? { tag: "firstMatch" },
+      autoNot
+    },
+    parse(input, pos, ctx) {
+      const expected = [];
+      if (disjoint && pos < input.length) {
+        const code = input.codePointAt(pos);
+        for (const parser2 of parsers) {
+          if (inFirstSet(code, parser2._meta.firstSet)) {
+            const result = parser2.parse(input, pos, ctx);
+            if (result.ok) return result;
+            expected.push(...result.expected);
+            return { ok: false, expected, span: { start: pos, end: pos } };
+          }
+        }
+        return {
+          ok: false,
+          expected: parsers.flatMap((p) => {
+            const r = p.parse(input, pos, ctx);
+            return r.ok ? [] : r.expected;
+          }),
+          span: { start: pos, end: pos }
+        };
+      }
+      if (strategy?.tag === "greedyClassify") {
+        const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
+        if (!superResult.ok) return superResult;
+        const end = superResult.span.end;
+        const litIdx = greedyLitMap.get(input.slice(pos, end));
+        if (litIdx !== void 0) {
+          const litVal = getCoreLiteralValue(parsers[litIdx]);
+          const value = applyTransforms(parsers[litIdx], litVal, { start: pos, end });
+          return { ok: true, value, span: { start: pos, end } };
+        }
+        return superResult;
+      }
+      if (strategy?.tag === "literalsLongestFirst") {
+        for (const p of sortedParsers) {
+          const r = p.parse(input, pos, ctx);
+          if (r.ok) return r;
+          expected.push(...r.expected);
+        }
+        return { ok: false, expected, span: { start: pos, end: pos } };
+      }
+      for (let i = 0; i < parsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.user)) continue;
+        const result = parsers[i].parse(input, pos, ctx);
+        if (!result.ok) {
+          expected.push(...result.expected);
+          continue;
+        }
+        const checks = autoNot[i];
+        if (checks && autoNotFires(input, result.span.end, checks)) continue;
+        return result;
+      }
+      return { ok: false, expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+function detectStrategy(parsers) {
+  const regexIndices = [];
+  const literalIndices = [];
+  for (let i = 0; i < parsers.length; i++) {
+    if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
+    else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
+  }
+  if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
+    const superIndex = regexIndices[0];
+    const regexDef = getCoreRegexDef(parsers[superIndex]);
+    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
+    const re = new RegExp(regexDef.source, flags);
+    const allSubsumed = literalIndices.every((i) => {
+      const litVal = getCoreLiteralValue(parsers[i]);
+      re.lastIndex = 0;
+      const m = re.exec(litVal);
+      return m !== null && m[0] === litVal;
+    });
+    if (allSubsumed) return { tag: "greedyClassify", superIndex };
+  }
+  if (parsers.length === literalIndices.length) {
+    const sortedIndices = [...literalIndices].sort(
+      (a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length
+    );
+    return { tag: "literalsLongestFirst", sortedIndices };
+  }
+  return { tag: "firstMatch" };
+}
+function computeAutoNot(parsers) {
+  return parsers.map((p, i) => {
+    const litVal = getCoreLiteralValue(p);
+    if (litVal === null) return null;
+    const checks = [];
+    for (let j = i + 1; j < parsers.length; j++) {
+      const other = parsers[j];
+      const otherLit = getCoreLiteralValue(other);
+      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
+        checks.push({ kind: "startsWith", value: otherLit.slice(litVal.length) });
+        continue;
+      }
+      const regexDef = getCoreRegexDef(other);
+      if (regexDef !== null) {
+        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
+        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
+      }
+    }
+    return checks.length > 0 ? checks : null;
+  });
+}
+function autoNotFires(input, end, checks) {
+  for (const check of checks) {
+    if (check.kind === "firstSet") {
+      const code = end < input.length ? input.codePointAt(end) ?? -1 : -1;
+      if (inFirstSet(code, check.set)) return true;
+    } else {
+      if (input.startsWith(check.value, end)) return true;
+    }
+  }
+  return false;
+}
+function getCoreLiteralValue(p) {
+  const def = p._def;
+  if (def.tag === "literal" && !def.caseInsensitive) return def.value;
+  if (def.tag === "transform") return getCoreLiteralValue(def.parser);
+  return null;
+}
+function getCoreRegexDef(p) {
+  const def = p._def;
+  if (def.tag === "regex") return { source: def.source, flags: def.flags };
+  if (def.tag === "transform") return getCoreRegexDef(def.parser);
+  return null;
+}
+function applyTransforms(p, value, span) {
+  const def = p._def;
+  if (def.tag === "transform") {
+    const inner = applyTransforms(def.parser, value, span);
+    return def.fn(inner, span);
+  }
+  return value;
+}
+function continuationFirstSet(lit, source, flags) {
+  const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
+  re.lastIndex = 0;
+  const base = re.exec(lit);
+  if (!base || base[0] !== lit) return null;
+  const contCodes = [];
+  for (let code = 1; code < 128; code++) {
+    re.lastIndex = 0;
+    const m = re.exec(lit + String.fromCharCode(code));
+    if (m && m[0].length > lit.length) contCodes.push(code);
+  }
+  if (contCodes.length === 0) return null;
+  return codesToFirstSet(contCodes);
+}
+function codesToFirstSet(codes) {
+  codes.sort((a, b) => a - b);
+  const ranges = [];
+  let lo = codes[0], hi = codes[0];
+  for (let i = 1; i < codes.length; i++) {
+    if (codes[i] === hi + 1) {
+      hi = codes[i];
+    } else {
+      ranges.push({ lo, hi });
+      lo = hi = codes[i];
+    }
+  }
+  ranges.push({ lo, hi });
+  return { kind: "ranges", ranges };
+}
+function inFirstSet(code, fs) {
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
+function areDisjoint(sets) {
+  if (sets.some((s) => s.kind === "any")) return false;
+  for (let i = 0; i < sets.length; i++)
+    for (let j = i + 1; j < sets.length; j++)
+      if (intersects(sets[i], sets[j])) return false;
+  return true;
+}
+
+// src/combinators/repeat.ts
+function many(parser2) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "many",
+    _meta: meta,
+    _def: { tag: "many", parser: parser2, min: 0 },
+    parse(input, pos, ctx) {
+      const values = [];
+      let cur = pos;
+      while (cur < input.length) {
+        const result = parser2.parse(input, cur, ctx);
+        if (!result.ok) break;
+        if (result.span.end === cur) break;
+        values.push(result.value);
+        cur = result.span.end;
+      }
+      return { ok: true, value: values, span: { start: pos, end: cur } };
+    }
+  };
+}
+function oneOrMore(parser2) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "oneOrMore",
+    _meta: meta,
+    _def: { tag: "oneOrMore", parser: parser2, min: 1 },
+    parse(input, pos, ctx) {
+      const first = parser2.parse(input, pos, ctx);
+      if (!first.ok) return first;
+      const values = [first.value];
+      let cur = first.span.end;
+      while (cur < input.length) {
+        const result = parser2.parse(input, cur, ctx);
+        if (!result.ok) break;
+        if (result.span.end === cur) break;
+        values.push(result.value);
+        cur = result.span.end;
+      }
+      return { ok: true, value: values, span: { start: pos, end: cur } };
+    }
+  };
+}
+function optional(parser2) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "optional",
+    _meta: meta,
+    _def: { tag: "optional", parser: parser2 },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      return { ok: true, value: null, span: { start: pos, end: pos } };
+    }
+  };
+}
+function sepBy(parser2, separator) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline || separator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "sepBy",
+    _meta: meta,
+    _def: { tag: "sepBy", parser: parser2, separator },
+    parse(input, pos, ctx) {
+      const first = parser2.parse(input, pos, ctx);
+      if (!first.ok) return { ok: true, value: [], span: { start: pos, end: pos } };
+      const values = [first.value];
+      let cur = first.span.end;
+      while (cur < input.length) {
+        let sepPos = cur;
+        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.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
+            sepPos = tr.span.end;
+          }
+        }
+        const sep = separator.parse(input, sepPos, ctx);
+        if (!sep.ok) break;
+        let nextPos = sep.span.end;
+        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.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
+            nextPos = tr.span.end;
+          }
+        }
+        const next = parser2.parse(input, nextPos, ctx);
+        if (!next.ok) break;
+        values.push(next.value);
+        cur = next.span.end;
+      }
+      return { ok: true, value: values, span: { start: pos, end: cur } };
+    }
+  };
+}
+
+// src/combinators/ref.ts
+function ref() {
+  let resolved = null;
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  const slot = {
+    _tag: "lazy",
+    _meta: meta,
+    _def: {
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        return resolved;
+      }
+    },
+    parse(input, pos, ctx) {
+      if (!resolved) throw new Error("ref<T>() used before .define() was called");
+      return resolved.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = p;
+    }
+  };
+  return slot;
+}
+
+// src/combinators/parser.ts
+function parser(factory) {
+  const cache = {};
+  const proxy = new Proxy(cache, {
+    get(target, key) {
+      if (typeof key !== "string") return void 0;
+      const record = target;
+      if (!(key in record)) {
+        record[key] = ref();
+      }
+      return record[key];
+    }
+  });
+  const definitions = factory(proxy);
+  for (const key of Object.keys(definitions)) {
+    const placeholder = cache[key];
+    const parser2 = definitions[key];
+    if (placeholder !== void 0 && typeof placeholder.define === "function") {
+      ;
+      placeholder.define(parser2);
+      placeholder._meta.firstSet = parser2._meta.firstSet;
+      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else {
+      ;
+      cache[key] = parser2;
+    }
+  }
+  return cache;
+}
+
+// src/combinators/not.ts
+function not(parser2) {
+  const meta = {
+    firstSet: any(),
+    // we don't know what NOT matches
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "unknown",
+    _meta: meta,
+    _def: { tag: "unknown" },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) {
+        return { ok: false, expected: [`not(${parser2._tag})`], span: { start: pos, end: pos } };
+      }
+      return { ok: true, value: null, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/map.ts
+function transform(parser2, fn) {
+  return {
+    _tag: "transform",
+    _meta: parser2._meta,
+    _def: { tag: "transform", parser: parser2, fn },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      return { ...result, value: fn(result.value, result.span) };
+    }
+  };
+}
+function skip(main, skipped) {
+  return {
+    _tag: "skip",
+    _meta: main._meta,
+    _def: { tag: "skip", main, skipped },
+    parse(input, pos, ctx) {
+      const result = main.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      const s = skipped.parse(input, result.span.end, ctx);
+      if (!s.ok) return result;
+      return { ...result, span: { start: result.span.start, end: s.span.end } };
+    }
+  };
+}
+function trivia(parser2) {
+  return {
+    _tag: parser2._tag,
+    _meta: { ...parser2._meta, isTrivia: true },
+    _def: { tag: "trivia", parser: parser2 },
+    parse: parser2.parse.bind(parser2)
+  };
+}
+
+// src/compiler/line-index.ts
+function buildLineIndex(input) {
+  const lineStarts = [0];
+  for (let i = 0; i < input.length; i++) {
+    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
+  }
+  return { lineStarts };
+}
+function offsetToLineCol(index, offset) {
+  const { lineStarts } = index;
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+}
+function annotateSpan(span, index) {
+  const s = offsetToLineCol(index, span.start);
+  const e = offsetToLineCol(index, span.end);
+  return {
+    ...span,
+    startLine: s.line,
+    startColumn: s.col,
+    endLine: e.line,
+    endColumn: e.col
+  };
+}
+
+// src/combinators/grammar.ts
+function parse(parser2, input, opts = {}) {
+  const trackLines = opts.trackLines ?? false;
+  const ctx = opts.trivia !== void 0 ? { trivia: opts.trivia, trackLines } : { trackLines };
+  const result = parser2.parse(input, 0, ctx);
+  if (trackLines) {
+    const idx = buildLineIndex(input);
+    return { ...result, span: annotateSpan(result.span, idx) };
+  }
+  return result;
+}
+
+// src/compiler/codegen.ts
+function v(ctx, prefix = "_v") {
+  return `${prefix}${ctx.vars++}`;
+}
+function ind(ctx) {
+  return "  ".repeat(ctx.indent);
+}
+function failStmt(ctx, expected, posExpr) {
+  return `${ind(ctx)}return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
+}
+function firstSetCond(codeVar, fs) {
+  if (fs.kind === "any") return "true";
+  if (fs.kind === "empty") return "false";
+  return fs.ranges.map(
+    (r) => r.lo === r.hi ? `${codeVar} === ${r.lo}` : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`
+  ).join(" || ");
+}
+function asIIFE(stmts, valueVar, endVar, startPos, indent) {
+  return [
+    `(() => {`,
+    ...stmts,
+    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,
+    `${indent}})()`
+  ].join("\n");
+}
+function emitLit(def, ctx, pos) {
+  const { value, caseInsensitive } = def;
+  const len = value.length;
+  const vv = v(ctx);
+  const expectedStr = JSON.stringify(JSON.stringify(value));
+  const stmts = [];
+  if (caseInsensitive) {
+    ctx.needsCollator = true;
+    stmts.push(
+      `${ind(ctx)}if (${pos} + ${len} > input.length) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,
+      `${ind(ctx)}if (_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      `${ind(ctx)}const ${vv} = ${vv}_s`
+    );
+  } else if (len === 0) {
+    stmts.push(`${ind(ctx)}const ${vv} = ''`);
+  } else if (len === 1) {
+    const code = value.codePointAt(0);
+    stmts.push(
+      `${ind(ctx)}if (${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
+    );
+  } else if (len <= 4) {
+    const checks = Array.from(
+      { length: len },
+      (_, i) => `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""}) !== ${value.codePointAt(i)}`
+    ).join(" || ");
+    stmts.push(
+      `${ind(ctx)}if (${pos} + ${len} > input.length || ${checks}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
+    );
+  } else {
+    stmts.push(
+      `${ind(ctx)}if (!input.startsWith(${JSON.stringify(value)}, ${pos})) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
+    );
+  }
+  return { stmts, valueVar: vv, endVar: len === 0 ? pos : `${pos} + ${len}` };
+}
+function emitRegex(def, ctx, pos) {
+  const flags = "y" + def.flags.replace(/[gy]/g, "");
+  const rName = `_re${ctx.regexDecls.length}`;
+  ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+  const mv = v(ctx, "_m");
+  const vv = v(ctx);
+  const expectedStr = JSON.stringify(`/${def.source}/`);
+  const stmts = [
+    `${ind(ctx)}${rName}.lastIndex = ${pos}`,
+    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,
+    `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+    `${ind(ctx)}const ${vv} = ${mv}[0]`
+  ];
+  return { stmts, valueVar: vv, endVar: `${pos} + ${vv}.length` };
+}
+function ensureTriviaFn(ctx) {
+  const trivia2 = ctx.activeTrivia;
+  if (!ctx.namedParsers.has(trivia2)) {
+    const fnName = `_pf${ctx.namedParsers.size}`;
+    ctx.namedParsers.set(trivia2, fnName);
+    const savedIndent = ctx.indent;
+    ctx.indent = 1;
+    const r = emit(trivia2, ctx, "_pos");
+    ctx.indent = savedIndent;
+    ctx.namedFnDecls.push([
+      `function ${fnName}(input, _pos, _ctx) {`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `}`
+    ].join("\n"));
+  }
+  return ctx.namedParsers.get(trivia2);
+}
+function emitSeq(def, ctx, pos) {
+  const startV = v(ctx, "_start");
+  const curV = v(ctx, "_cur");
+  const stmts = [
+    `${ind(ctx)}const ${startV} = ${pos}`,
+    `${ind(ctx)}let ${curV} = ${pos}`
+  ];
+  const valueVars = [];
+  for (let i = 0; i < def.parsers.length; i++) {
+    if (i > 0 && ctx.activeTrivia) {
+      const trivFn = ensureTriviaFn(ctx);
+      const tmp = v(ctx, "_trv");
+      stmts.push(
+        `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
+        `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
+      );
+    }
+    const r = emit(def.parsers[i], ctx, curV);
+    stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`);
+    valueVars.push(r.valueVar);
+  }
+  const arrV = v(ctx, "_arr");
+  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(", ")}]`);
+  return { stmts, valueVar: arrV, endVar: curV };
+}
+function emitChoice(def, ctx, pos) {
+  const allExpected = JSON.stringify(
+    def.parsers.map((p) => {
+      const d = p._def;
+      if (d.tag === "literal") return JSON.stringify(d.value);
+      if (d.tag === "regex") return `/${d.source}/`;
+      return p._tag;
+    })
+  );
+  if (def.disjoint) {
+    const codeV = v(ctx, "_code");
+    const valV = v(ctx, "_chv");
+    const endV = v(ctx, "_che");
+    const stmts = [
+      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
+      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`
+    ];
+    let first = true;
+    for (const p of def.parsers) {
+      const cond = firstSetCond(codeV, p._meta.firstSet);
+      const kw = first ? "if" : "else if";
+      first = false;
+      stmts.push(`${ind(ctx)}${kw} (${cond}) {`);
+      ctx.indent++;
+      const r = emit(p, ctx, pos);
+      stmts.push(...r.stmts);
+      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}; ${endV} = ${r.endVar}`);
+      ctx.indent--;
+      stmts.push(`${ind(ctx)}}`);
+    }
+    stmts.push(
+      `${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
+    );
+    return { stmts, valueVar: valV, endVar: endV };
+  }
+  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
+}
+function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
+  const superParser = def.parsers[superIndex];
+  const regexDef = getCoreRegexDef(superParser);
+  const reIdx = ctx.regexDecls.length;
+  const reVar = `_re${reIdx}`;
+  const cleanFlags = "y" + regexDef.flags.replace(/[gy]/g, "");
+  ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
+  const matchV = v(ctx, "_gm");
+  const wordV = v(ctx, "_gw");
+  const endV = v(ctx, "_ge");
+  const stmts = [
+    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
+    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
+    `${ind(ctx)}if (${matchV} === null) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,
+    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
+    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`
+  ];
+  for (let i = 0; i < def.parsers.length; i++) {
+    if (i === superIndex) continue;
+    const p = def.parsers[i];
+    const litVal = getCoreLiteralValue(p);
+    if (litVal === null) continue;
+    stmts.push(`${ind(ctx)}if (${wordV} === ${JSON.stringify(litVal)}) {`);
+    ctx.indent++;
+    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx);
+    stmts.push(...tR.stmts);
+    stmts.push(`${ind(ctx)}return { ok: true, value: ${tR.valueVar}, span: { start: ${pos}, end: ${endV} } }`);
+    ctx.indent--;
+    stmts.push(`${ind(ctx)}}`);
+  }
+  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx);
+  stmts.push(...rR.stmts);
+  return { stmts, valueVar: rR.valueVar, endVar: endV };
+}
+function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
+  const valV = v(ctx, "_llv");
+  const endV = v(ctx, "_lle");
+  const stmts = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`];
+  let first = true;
+  for (const idx of sortedIndices) {
+    const p = def.parsers[idx];
+    const litVal = getCoreLiteralValue(p);
+    const litLen = litVal.length;
+    const litCond = emitLiteralCondition(litVal, pos);
+    const kw = first ? "if" : "else if";
+    first = false;
+    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`);
+    ctx.indent++;
+    const tR = emitTransformChain(p, JSON.stringify(litVal), `${pos} + ${litLen}`, pos, ctx);
+    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}; ${endV} = ${pos} + ${litLen}`);
+    ctx.indent--;
+    stmts.push(`${ind(ctx)}}`);
+  }
+  stmts.push(`${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`);
+  return { stmts, valueVar: valV, endVar: endV };
+}
+function emitFirstMatch(def, allExpected, ctx, pos) {
+  const resV = v(ctx, "_cr");
+  const stmts = [`${ind(ctx)}let ${resV}`];
+  for (let i = 0; i < def.parsers.length; i++) {
+    const p = def.parsers[i];
+    const gate = def.gates[i];
+    const autoNot = def.autoNot[i];
+    const savedIndent = ctx.indent;
+    ctx.indent = 0;
+    const r = emit(p, ctx, pos);
+    ctx.indent = savedIndent;
+    const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
+    let gateCond = null;
+    if (gate) {
+      const gateIdx = ctx.mapFns.length;
+      ctx.mapFns.push(gate);
+      gateCond = `_mf[${gateIdx}](_ctx.user)`;
+    }
+    const skipCond = gateCond ? `!${resV}?.ok && ${gateCond}` : `!${resV}?.ok`;
+    if (autoNot && autoNot.length > 0) {
+      const tmp = v(ctx, "_ct");
+      const anCode = v(ctx, "_anc");
+      const rejectCond = autoNot.map(
+        (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${tmp}.span.end)`
+      ).join(" || ");
+      stmts.push(
+        `${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} } }`
+      );
+    } else {
+      stmts.push(`${ind(ctx)}if (${skipCond}) { try { ${resV} = ${iife} } catch {} }`);
+    }
+  }
+  stmts.push(
+    `${ind(ctx)}if (!${resV}?.ok) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
+  );
+  return { stmts, valueVar: `${resV}.value`, endVar: `${resV}.span.end` };
+}
+function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
+  if (strategy.tag === "greedyClassify")
+    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
+  if (strategy.tag === "literalsLongestFirst")
+    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
+  return emitFirstMatch(def, allExpected, ctx, pos);
+}
+function emitTransformChain(p, baseValue, endV, startPos, ctx) {
+  const def = p._def;
+  if (def.tag === "transform") {
+    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx);
+    const fnIdx = ctx.mapFns.length;
+    ctx.mapFns.push(def.fn);
+    const vv = v(ctx);
+    return {
+      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
+      valueVar: vv,
+      endVar: endV
+    };
+  }
+  return { stmts: [], valueVar: baseValue, endVar: endV };
+}
+function emitLiteralCondition(litVal, pos) {
+  const len = litVal.length;
+  if (len === 0) return "true";
+  if (len > 4) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`;
+  const checks = [`${pos} + ${len} <= input.length`];
+  for (let i = 0; i < len; i++) {
+    const code = litVal.codePointAt(i);
+    checks.push(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""}) === ${code}`);
+  }
+  return checks.join(" && ");
+}
+function emitMany(def, ctx, pos) {
+  const arrV = v(ctx, "_arr");
+  const curV = v(ctx, "_cur");
+  const stmts = [
+    `${ind(ctx)}const ${arrV} = []`,
+    `${ind(ctx)}let ${curV} = ${pos}`
+  ];
+  const emitInnerIIFE = () => {
+    const savedIndent = ctx.indent;
+    ctx.indent = 0;
+    const r = emit(def.parser, ctx, curV);
+    ctx.indent = savedIndent;
+    return asIIFE(r.stmts, r.valueVar, r.endVar, curV, ind(ctx) + "  ");
+  };
+  if (def.min === 1) {
+    const firstR = emit(def.parser, ctx, curV);
+    stmts.push(...firstR.stmts);
+    stmts.push(
+      `${ind(ctx)}${arrV}.push(${firstR.valueVar})`,
+      `${ind(ctx)}${curV} = ${firstR.endVar}`
+    );
+  }
+  stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
+  ctx.indent++;
+  stmts.push(
+    `${ind(ctx)}const _iter = (() => { try { return ${emitInnerIIFE()} } catch { return null } })()`,
+    `${ind(ctx)}if (!_iter?.ok || _iter.span.end === ${curV}) break`,
+    `${ind(ctx)}${arrV}.push(_iter.value)`,
+    `${ind(ctx)}${curV} = _iter.span.end`
+  );
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}}`);
+  return { stmts, valueVar: arrV, endVar: curV };
+}
+function emitOptional(def, ctx, pos) {
+  const valV = v(ctx, "_opt");
+  const endV = v(ctx, "_opte");
+  const savedIndent = ctx.indent;
+  ctx.indent = 0;
+  const r = emit(def.parser, ctx, pos);
+  ctx.indent = savedIndent;
+  const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
+  const resV = v(ctx, "_optr");
+  const stmts = [
+    `${ind(ctx)}const ${resV} = (() => { try { return ${iife} } catch { return null } })()`,
+    `${ind(ctx)}const ${valV} = ${resV}?.ok ? ${resV}.value : null`,
+    `${ind(ctx)}const ${endV} = ${resV}?.ok ? ${resV}.span.end : ${pos}`
+  ];
+  return { stmts, valueVar: valV, endVar: endV };
+}
+function emitSepBy(_p, def, ctx, pos) {
+  const arrV = v(ctx, "_arr");
+  const curV = v(ctx, "_cur");
+  const iife = (inner, posExpr) => {
+    const saved = ctx.indent;
+    ctx.indent = 0;
+    const r = emit(inner, ctx, posExpr);
+    ctx.indent = saved;
+    return asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx));
+  };
+  const firstR_saved = ctx.indent;
+  ctx.indent = 0;
+  const firstR = emit(def.parser, ctx, pos);
+  ctx.indent = firstR_saved;
+  const firstV = v(ctx, "_sb0");
+  const sepV = v(ctx, "_sbs");
+  const nextV = v(ctx, "_sbn");
+  const stmts = [
+    `${ind(ctx)}const ${arrV} = []`,
+    `${ind(ctx)}let ${curV} = ${pos}`,
+    `${ind(ctx)}const ${firstV} = (() => { try { return ${asIIFE(firstR.stmts, firstR.valueVar, firstR.endVar, pos, ind(ctx))} } catch { return null } })()`,
+    `${ind(ctx)}if (${firstV}?.ok) {`
+  ];
+  ctx.indent++;
+  stmts.push(
+    `${ind(ctx)}${arrV}.push(${firstV}.value)`,
+    `${ind(ctx)}${curV} = ${firstV}.span.end`,
+    `${ind(ctx)}while (${curV} < input.length) {`
+  );
+  ctx.indent++;
+  stmts.push(
+    `${ind(ctx)}const ${sepV} = (() => { try { return ${iife(def.separator, curV)} } catch { return null } })()`,
+    `${ind(ctx)}if (!${sepV}?.ok) break`,
+    `${ind(ctx)}const ${nextV} = (() => { try { return ${iife(def.parser, `${sepV}.span.end`)} } catch { return null } })()`,
+    `${ind(ctx)}if (!${nextV}?.ok) break`,
+    `${ind(ctx)}${arrV}.push(${nextV}.value)`,
+    `${ind(ctx)}${curV} = ${nextV}.span.end`
+  );
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}}`);
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}}`);
+  return { stmts, valueVar: arrV, endVar: curV };
+}
+function emitScanTo(def, ctx, pos) {
+  const safeIIFE = (inner, posExpr) => {
+    const saved = ctx.indent;
+    ctx.indent = 0;
+    const r = emit(inner, ctx, posExpr);
+    ctx.indent = saved;
+    return `(() => { try { return ${asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx))} } catch { return null } })()`;
+  };
+  const curV = v(ctx, "_stcur");
+  const foundV = v(ctx, "_stfnd");
+  const stmts = [
+    `${ind(ctx)}let ${curV} = ${pos}`,
+    `${ind(ctx)}let ${foundV} = false`,
+    `${ind(ctx)}while (${curV} < input.length) {`
+  ];
+  ctx.indent++;
+  const sentV = v(ctx, "_sts");
+  stmts.push(
+    `${ind(ctx)}const ${sentV} = ${safeIIFE(def.sentinel, curV)}`,
+    `${ind(ctx)}if (${sentV}?.ok) { ${foundV} = true; break }`
+  );
+  if (def.skip.length > 0) {
+    const advV = v(ctx, "_stadv");
+    stmts.push(`${ind(ctx)}let ${advV} = false`);
+    for (const skipper of def.skip) {
+      const skV = v(ctx, "_sk");
+      stmts.push(
+        `${ind(ctx)}if (!${advV}) { const ${skV} = ${safeIIFE(skipper, curV)}; if (${skV}?.ok && ${skV}.span.end > ${curV}) { ${curV} = ${skV}.span.end; ${advV} = true } }`
+      );
+    }
+    stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`);
+  } else {
+    stmts.push(`${ind(ctx)}${curV}++`);
+  }
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}}`);
+  if (!def.orEOF) {
+    const sentDef = def.sentinel._def;
+    const expectedStr = sentDef.tag === "literal" ? JSON.stringify([JSON.stringify(sentDef.value)]) : `["sentinel"]`;
+    stmts.push(
+      `${ind(ctx)}if (!${foundV}) return { ok: false, expected: ${expectedStr}, span: { start: ${pos}, end: ${curV} } }`
+    );
+  }
+  const valV = v(ctx);
+  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`);
+  return { stmts, valueVar: valV, endVar: curV };
+}
+function emitRuntimeFallback(parser2, ctx, pos) {
+  const idx = ctx.runtimeParsers.length;
+  ctx.runtimeParsers.push(parser2);
+  const rv = v(ctx, "_rt");
+  const vv = v(ctx, "_rtv");
+  const ev = v(ctx, "_rte");
+  const stmts = [
+    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
+    `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+    `${ind(ctx)}const ${vv} = ${rv}.value`,
+    `${ind(ctx)}const ${ev} = ${rv}.span.end`
+  ];
+  return { stmts, valueVar: vv, endVar: ev };
+}
+function emitLazy(p, def, ctx, pos) {
+  if (!ctx.namedParsers.has(p)) {
+    const fnName2 = `_pf${ctx.namedParsers.size}`;
+    ctx.namedParsers.set(p, fnName2);
+    let resolved;
+    try {
+      resolved = def.thunk();
+    } catch {
+      ctx.namedParsers.delete(p);
+      return emitRuntimeFallback(p, ctx, pos);
+    }
+    const savedIndent = ctx.indent;
+    ctx.indent = 1;
+    const r = emit(resolved, ctx, "_pos");
+    ctx.indent = savedIndent;
+    ctx.namedFnDecls.push([
+      `function ${fnName2}(input, _pos, _ctx) {`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `}`
+    ].join("\n"));
+  }
+  const fnName = ctx.namedParsers.get(p);
+  const rv = v(ctx, "_pfr");
+  const vv = v(ctx, "_pfv");
+  const ev = v(ctx, "_pfe");
+  return {
+    stmts: [
+      `${ind(ctx)}const ${rv} = ${fnName}(input, ${pos}, _ctx)`,
+      `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+      `${ind(ctx)}const ${vv} = ${rv}.value`,
+      `${ind(ctx)}const ${ev} = ${rv}.span.end`
+    ],
+    valueVar: vv,
+    endVar: ev
+  };
+}
+function emit(p, ctx, pos) {
+  const def = p._def;
+  switch (def.tag) {
+    case "literal":
+      return emitLit(def, ctx, pos);
+    case "regex":
+      return emitRegex(def, ctx, pos);
+    case "sequence":
+      return emitSeq(def, ctx, pos);
+    case "choice":
+      return emitChoice(def, ctx, pos);
+    case "many":
+    case "oneOrMore":
+      return emitMany(def, ctx, pos);
+    case "optional":
+      return emitOptional(def, ctx, pos);
+    case "sepBy":
+      return emitSepBy(p, def, ctx, pos);
+    case "transform": {
+      const inner = emit(def.parser, ctx, pos);
+      const fnIdx = ctx.mapFns.length;
+      ctx.mapFns.push(def.fn);
+      const mv = v(ctx, "_mapped");
+      return {
+        stmts: [
+          ...inner.stmts,
+          `${ind(ctx)}const ${mv} = _mf[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`
+        ],
+        valueVar: mv,
+        endVar: inner.endVar
+      };
+    }
+    case "skip": {
+      const mainR = emit(def.main, ctx, pos);
+      const skipR = emit(def.skipped, ctx, mainR.endVar);
+      const endV = v(ctx, "_skipe");
+      return {
+        stmts: [
+          ...mainR.stmts,
+          // try skipped; if fails, keep main end
+          `${ind(ctx)}let ${endV} = ${mainR.endVar}`,
+          `${ind(ctx)}try {`,
+          ...skipR.stmts.map((s) => "  " + s),
+          `${ind(ctx)}  ${endV} = ${skipR.endVar}`,
+          `${ind(ctx)}} catch {}`
+        ],
+        valueVar: mainR.valueVar,
+        endVar: endV
+      };
+    }
+    case "lazy":
+      return emitLazy(p, def, ctx, pos);
+    case "trivia":
+      return emit(def.parser, ctx, pos);
+    case "grammar": {
+      const savedTrivia = ctx.activeTrivia;
+      if (def.triviaParser) ctx.activeTrivia = def.triviaParser;
+      const r = emit(def.parser, ctx, pos);
+      if (savedTrivia === void 0) delete ctx.activeTrivia;
+      else ctx.activeTrivia = savedTrivia;
+      return r;
+    }
+    case "scanTo":
+      return emitScanTo(def, ctx, pos);
+    case "guard": {
+      const fnIdx = ctx.mapFns.length;
+      ctx.mapFns.push(def.predicate);
+      const vv = v(ctx);
+      return {
+        stmts: [
+          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.user)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
+          `${ind(ctx)}const ${vv} = null`
+        ],
+        valueVar: vv,
+        endVar: pos
+      };
+    }
+    case "withCtx": {
+      const evIdx = ctx.mapFns.length;
+      const extra = def.extra;
+      ctx.mapFns.push((() => extra));
+      const innerParser = def.parser;
+      if (!ctx.namedParsers.has(innerParser)) {
+        const fnName = `_wcf${ctx.namedParsers.size}`;
+        ctx.namedParsers.set(innerParser, fnName);
+        const savedIndent = ctx.indent;
+        ctx.indent = 1;
+        const innerR = emit(innerParser, ctx, "_pos");
+        ctx.indent = savedIndent;
+        ctx.namedFnDecls.push([
+          `function ${fnName}(input, _pos, _ctx) {`,
+          ...innerR.stmts,
+          `  return { ok: true, value: ${innerR.valueVar}, span: { start: _pos, end: ${innerR.endVar} } }`,
+          `}`
+        ].join("\n"));
+      }
+      const fn = ctx.namedParsers.get(innerParser);
+      const rv = v(ctx, "_wcr");
+      const vv = v(ctx);
+      const ev = v(ctx, "_wce");
+      return {
+        stmts: [
+          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, user: _mf[${evIdx}]() })`,
+          `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+          `${ind(ctx)}const ${vv} = ${rv}.value`,
+          `${ind(ctx)}const ${ev} = ${rv}.span.end`
+        ],
+        valueVar: vv,
+        endVar: ev
+      };
+    }
+    default:
+      return emitRuntimeFallback(p, ctx, pos);
+  }
+}
+function compile(parser2) {
+  const ctx = {
+    vars: 0,
+    indent: 1,
+    regexDecls: [],
+    mapFns: [],
+    runtimeParsers: [],
+    needsCollator: false,
+    namedParsers: /* @__PURE__ */ new Map(),
+    namedFnDecls: []
+  };
+  const r = emit(parser2, ctx, "_pos");
+  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
+` : "";
+  const source = [
+    ...ctx.regexDecls,
+    "",
+    ...ctx.namedFnDecls,
+    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _ctx) {`,
+    `  let pos = _pos`,
+    ...r.stmts,
+    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+    `}`
+  ].join("\n");
+  const fn = new Function("input", "_pos", "_rp", "_mf", "_ctx", [
+    ...ctx.regexDecls,
+    collatorDecl,
+    ...ctx.namedFnDecls,
+    `let pos = _pos`,
+    ...r.stmts,
+    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+  ].join("\n"));
+  const defaultCtx = { trackLines: false };
+  const canInline = ctx.runtimeParsers.length === 0 && ctx.mapFns.length === 0;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl) : null;
+  return {
+    source,
+    inlineExpression,
+    parse(input, pos = 0) {
+      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, defaultCtx);
+    }
+  };
+}
+function buildInlineExpression(ctx, r, collatorDecl) {
+  const bodyLines = [
+    `  let pos = _pos`,
+    ...r.stmts.map((s) => `  ${s}`),
+    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+  ];
+  const innerFn = [
+    `function(input, _pos, _ctx) {`,
+    ...bodyLines,
+    `}`
+  ].join("\n");
+  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0;
+  if (!needsWrapper) {
+    return innerFn;
+  }
+  return [
+    `/* @__PURE__ */ (() => {`,
+    ...ctx.regexDecls.map((d) => `  ${d}`),
+    collatorDecl ? `  ${collatorDecl.trim()}` : "",
+    ...ctx.namedFnDecls.flatMap((f) => f.split("\n").map((l) => `  ${l}`)),
+    `  return ${innerFn}`,
+    `})()`
+  ].filter(Boolean).join("\n");
+}
+
+// src/combinators/guard.ts
+function guard(predicate) {
+  const meta = {
+    firstSet: { kind: "any" },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "guard",
+    _meta: meta,
+    _def: { tag: "guard", predicate },
+    parse(_input, pos, ctx) {
+      if (predicate(ctx.user))
+        return { ok: true, value: null, span: { start: pos, end: pos } };
+      return { ok: false, expected: ["guard"], span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/withCtx.ts
+function withCtx(extra, parser2) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "withCtx",
+    _meta: meta,
+    _def: { tag: "withCtx", extra, parser: parser2 },
+    parse(input, pos, ctx) {
+      return parser2.parse(input, pos, { ...ctx, user: extra });
+    }
+  };
+}
+
+// src/combinators/recover.ts
+function recover(parser2, sentinel) {
+  const meta = {
+    firstSet: { kind: "any" },
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  return {
+    _tag: "recover",
+    _meta: meta,
+    _def: { tag: "recover", parser: parser2, sentinel },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      let scanPos = pos;
+      while (scanPos < input.length) {
+        if (sentinel.parse(input, scanPos, ctx).ok) break;
+        scanPos++;
+      }
+      const error = {
+        _tag: "parseError",
+        span: { start: pos, end: scanPos },
+        expected: result.expected
+      };
+      return { ok: true, value: error, span: { start: pos, end: scanPos } };
+    }
+  };
+}
+function isParseError(value) {
+  return typeof value === "object" && value !== null && value._tag === "parseError";
+}
+
+// src/combinators/scanTo.ts
+function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  return {
+    _tag: "scanTo",
+    _meta: meta,
+    _def: { tag: "scanTo", sentinel, skip: skip2, orEOF },
+    parse(input, pos, ctx) {
+      let cur = pos;
+      while (cur < input.length) {
+        const s = sentinel.parse(input, cur, ctx);
+        if (s.ok) {
+          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+        }
+        let advanced = false;
+        for (const skipper of skip2) {
+          const r = skipper.parse(input, cur, ctx);
+          if (r.ok && r.span.end > cur) {
+            cur = r.span.end;
+            advanced = true;
+            break;
+          }
+        }
+        if (!advanced) cur++;
+      }
+      if (orEOF) {
+        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+      }
+      const sentDef = sentinel._def;
+      const expected = sentDef.tag === "literal" ? [JSON.stringify(sentDef.value)] : ["sentinel"];
+      return { ok: false, expected, span: { start: pos, end: cur } };
+    }
+  };
+}
+function balanced(open, close, options = {}) {
+  const inner = scanTo(literal(close), options);
+  return transform(
+    sequence(literal(open), inner, literal(close)),
+    ([o, content, c]) => o + content + c
+  );
+}
+
+// src/cst/incremental.ts
+function isNode(x) {
+  return typeof x === "object" && x !== null && x._tag === "node";
+}
+function findContaining(node, pos, path = []) {
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    if (!isNode(child)) continue;
+    if (child.span.start <= pos && pos < child.span.end) {
+      return findContaining(child, pos, [...path, i]) ?? { node: child, path: [...path, i] };
+    }
+  }
+  return null;
+}
+function ancestorsAt(root, path) {
+  const ancestors = [root];
+  let cur = root;
+  for (const idx of path.slice(0, -1)) {
+    const child = cur.children[idx];
+    if (!child || !isNode(child)) break;
+    ancestors.push(child);
+    cur = child;
+  }
+  return ancestors;
+}
+function replaceAtPath(grammar, root, path, newNode) {
+  if (path.length === 0) return newNode;
+  const [idx, ...rest] = path;
+  const newChildren = [...root.children];
+  newChildren[idx] = rest.length === 0 ? newNode : replaceAtPath(grammar, root.children[idx], rest, newNode);
+  return grammar.rebuild(root, newChildren);
+}
+var ParseDocImpl = class _ParseDocImpl {
+  _parser;
+  _ruleName;
+  tree;
+  errors;
+  input;
+  constructor(parser2, ruleName, tree, errors, input) {
+    this._parser = parser2;
+    this._ruleName = ruleName;
+    this.tree = tree;
+    this.errors = errors;
+    this.input = input;
+  }
+  edit(changeStart, oldChangeEnd, newText) {
+    const newInput = this.input.slice(0, changeStart) + newText + this.input.slice(oldChangeEnd);
+    if (!this.tree) return makeParseDoc(this._parser, this._ruleName, newInput);
+    const delta = newText.length - (oldChangeEnd - changeStart);
+    const found = findContaining(this.tree, changeStart);
+    if (!found) return makeParseDoc(this._parser, this._ruleName, newInput);
+    const ancestors = ancestorsAt(this.tree, found.path);
+    const candidates = [found];
+    const pathCopy = [...found.path];
+    for (let i = ancestors.length - 2; i >= 0; i--) {
+      pathCopy.pop();
+      candidates.push({ node: ancestors[i + 1], path: [...pathCopy] });
+    }
+    for (const candidate of candidates) {
+      const { node, path } = candidate;
+      const expectedEnd = node.span.end + delta;
+      const parser2 = this._parser.rule(node.type);
+      const ctx = { trackLines: false, user: node.savedContext };
+      const r = parser2.parse(newInput, node.span.start, ctx);
+      if (!r.ok) continue;
+      if (r.span.end === expectedEnd) {
+        const newTree = replaceAtPath(this._parser, this.tree, path, r.value);
+        return new _ParseDocImpl(this._parser, this._ruleName, newTree, [], newInput);
+      }
+    }
+    return makeParseDoc(this._parser, this._ruleName, newInput);
+  }
+};
+function makeParseDoc(parser2, ruleName, input) {
+  const ctx = { trackLines: false };
+  const r = parser2.rule(ruleName).parse(input, 0, ctx);
+  if (r.ok) {
+    return new ParseDocImpl(parser2, ruleName, r.value, [], input);
+  }
+  return new ParseDocImpl(parser2, ruleName, null, [{ ok: false, expected: r.expected, span: r.span }], input);
+}
+
+// src/cst/grammar.ts
+var Parser = class {
+  _built = false;
+  _build() {
+    if (this._built) return;
+    this._built = true;
+    const keys = Object.keys(this).filter((k) => !k.startsWith("_"));
+    const slots = /* @__PURE__ */ new Map();
+    const g = {};
+    for (const key of keys) {
+      const val = this[key];
+      if (isCombinator(val)) {
+        const isRule = /^[A-Z]/.test(key);
+        const final = isRule ? this._makeNodeParser(key, val) : val;
+        g[key] = final;
+        Object.defineProperty(this, key, { value: final, writable: false, configurable: false });
+      } else if (typeof val === "function") {
+        const slot = ref();
+        slots.set(key, slot);
+        g[key] = slot;
+      }
+    }
+    for (const [key, slot] of slots) {
+      const thunk = this[key];
+      const inner = thunk(g);
+      const isRule = /^[A-Z]/.test(key);
+      const final = isRule ? this._makeNodeParser(key, inner) : inner;
+      slot.define(final);
+      slot._meta.firstSet = final._meta.firstSet;
+      slot._meta.canMatchNewline = final._meta.canMatchNewline;
+      Object.defineProperty(this, key, { value: final, writable: false, configurable: false });
+    }
+  }
+  /**
+   * Override to produce a custom AST node instead of a plain CSTNode.
+   * The returned object must satisfy NodeLike for IncrementalParser to work.
+   *
+   * `rawChildren` is `children` plus any trivia tokens (whitespace/comments)
+   * consumed between terms, in parse order. Use it to inspect trivia when the
+   * grammar is whitespace-sensitive (e.g. CSS descendant vs adjacent combinators).
+   * The default implementation ignores `rawChildren`.
+   */
+  buildNode(type, span, children, savedContext, _rawChildren) {
+    return { _tag: "node", type, span, children, savedContext };
+  }
+  /** Wrap an inner combinator so it produces a CSTNode on each match. */
+  _makeNodeParser(type, inner) {
+    const self = this;
+    const meta = {
+      firstSet: inner._meta.firstSet,
+      canMatchNewline: inner._meta.canMatchNewline,
+      isTrivia: false
+    };
+    return {
+      _tag: "cstNode",
+      _meta: meta,
+      _def: { tag: "unknown" },
+      parse(input, pos, ctx) {
+        const savedContext = ctx.user !== void 0 ? Object.assign({}, ctx.user) : void 0;
+        const children = [];
+        const rawChildren = [];
+        const innerCtx = {
+          ...ctx,
+          _cstChildren: children,
+          _cstLeaves: children,
+          _cstRawChildren: rawChildren
+        };
+        const r = inner.parse(input, pos, innerCtx);
+        if (!r.ok) return r;
+        const node = self.buildNode(type, r.span, children, savedContext, rawChildren);
+        if (ctx._cstChildren) ctx._cstChildren.push(node);
+        if (ctx._cstRawChildren) ctx._cstRawChildren.push(node);
+        return { ok: true, value: node, span: r.span };
+      }
+    };
+  }
+  /** Reconstruct a node with a new children array (used by IncrementalParser). */
+  rebuild(node, newChildren) {
+    return this.buildNode(node.type, node.span, newChildren, node.savedContext, []);
+  }
+  /**
+   * Parse input starting from a named rule, returning a ParseDoc.
+   * The doc carries the tree, any parse errors, and an edit() method
+   * for incremental re-parsing on subsequent changes.
+   *
+   *   const doc = css.parse('Stylesheet', src)
+   *   doc.tree    // the CST root, or null on failure
+   *   doc.errors  // ParseFail[], empty on success
+   *
+   *   // In an editor — just keep calling edit():
+   *   const doc2 = doc.edit(newSrc, changeStart, changeEnd)
+   */
+  parse(ruleName, input) {
+    return makeParseDoc(this, ruleName, input);
+  }
+  /**
+   * Get the compiled Combinator for a named rule.
+   * Triggers lazy initialization on first call.
+   */
+  rule(name) {
+    this._build();
+    const p = this[name];
+    if (!p) throw new Error(`No rule '${String(name)}' on this parser`);
+    return p;
+  }
+};
+function isCombinator(val) {
+  return val !== null && typeof val === "object" && "_tag" in val;
+}
+//# sourceMappingURL=index.cjs.map