parseman 0.1.0

package/dist/plugin/index.cjs

@@ -0,0 +1,1473 @@
+"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/plugin/index.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  default: () => plugin_default,
+  transformMacro: () => transformMacro
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_unplugin = require("unplugin");
+var import_oxc_parser = require("oxc-parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+
+// 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/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/plugin/evaluator.ts
+var SUPPORTED = {
+  literal: (...a) => literal(a[0], a[1]),
+  regex: (...a) => regex(a[0], a[1]),
+  sequence: (...a) => sequence(...a),
+  choice: (...a) => choice(...a),
+  many: (...a) => many(a[0]),
+  oneOrMore: (...a) => oneOrMore(a[0]),
+  optional: (...a) => optional(a[0]),
+  sepBy: (...a) => sepBy(a[0], a[1])
+  // transform / grammar intentionally omitted — take user closures that can't be serialized
+};
+function evaluateExpr(node, scope) {
+  if (node.type === "Identifier") return scope.get(node.name) ?? null;
+  if (node.type !== "CallExpression") return null;
+  const callee = node.callee;
+  if (callee.type !== "Identifier") return null;
+  const factory = SUPPORTED[callee.name];
+  if (!factory) return null;
+  const args = node.arguments.map((arg) => {
+    if (arg.type === "SpreadElement") return null;
+    return evaluateArg(arg, scope);
+  });
+  if (args.some((a) => a === null)) return null;
+  try {
+    return factory(...args);
+  } catch {
+    return null;
+  }
+}
+function evaluateArg(node, scope) {
+  if (node.type === "Literal") {
+    if ("regex" in node && node.regex !== null && node.regex !== void 0) {
+      return new RegExp(node.regex.pattern, node.regex.flags);
+    }
+    return node.value;
+  }
+  if (node.type === "ObjectExpression") {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type !== "Property") return null;
+      if (prop.computed) return null;
+      const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? String(prop.key.value) : null;
+      if (key === null) return null;
+      obj[key] = evaluateArg(prop.value, scope);
+    }
+    return obj;
+  }
+  if (node.type === "Identifier") {
+    if (node.name === "undefined") return void 0;
+    return scope.get(node.name) ?? null;
+  }
+  if (node.type === "CallExpression") return evaluateExpr(node, scope);
+  return null;
+}
+function referencesAny(node, names, scope) {
+  if (node.type === "Identifier") {
+    return names.has(node.name) || scope.has(node.name);
+  }
+  for (const key of Object.keys(node)) {
+    const child = node[key];
+    if (!child || typeof child !== "object") continue;
+    if (Array.isArray(child)) {
+      if (child.some((c) => c && typeof c === "object" && "type" in c && referencesAny(c, names, scope))) return true;
+    } else if ("type" in child) {
+      if (referencesAny(child, names, scope)) return true;
+    }
+  }
+  return false;
+}
+
+// src/plugin/index.ts
+var PARSEMAN_MODULE = "parseman";
+var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
+  name: "parseman",
+  transformInclude(id) {
+    return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
+  },
+  transform(code, id) {
+    if (!code.includes("parseman")) return null;
+    if (!code.includes("macro")) return null;
+    const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
+    return transformMacro(code, id, moduleAliases);
+  }
+}));
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE])) {
+  let result;
+  try {
+    result = (0, import_oxc_parser.parseSync)(id, code);
+  } catch {
+    return null;
+  }
+  if (result.errors.length > 0) return null;
+  const body = result.program.body;
+  const macroImports = [];
+  const allNames = /* @__PURE__ */ new Set();
+  for (const stmt of body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const s = stmt;
+    if (!moduleAliases.has(s.source.value)) continue;
+    const isMacro = s.attributes.some((a) => {
+      const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
+      return key === "type" && a.value.value === "macro";
+    });
+    if (!isMacro) continue;
+    const names = /* @__PURE__ */ new Set();
+    for (const spec of s.specifiers) {
+      if (spec.type === "ImportSpecifier") names.add(spec.local.name);
+    }
+    macroImports.push({ start: s.start, end: s.end, names, fullyResolved: false });
+    for (const n of names) allNames.add(n);
+  }
+  if (macroImports.length === 0) return null;
+  const scope = /* @__PURE__ */ new Map();
+  const replacements = [];
+  let anyUnresolved = false;
+  for (const stmt of body) {
+    if (stmt.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations) {
+      const d = decl;
+      if (!d.init) continue;
+      if (d.id.type !== "Identifier") continue;
+      const varName = d.id.name;
+      const init = d.init;
+      if (!referencesAny(init, allNames, scope)) continue;
+      const parser2 = evaluateExpr(init, scope);
+      if (parser2 === null) {
+        anyUnresolved = true;
+        continue;
+      }
+      const compiled = compile(parser2);
+      if (compiled.inlineExpression === null) {
+        anyUnresolved = true;
+        continue;
+      }
+      replacements.push({
+        start: init.start,
+        end: init.end,
+        replacement: compiled.inlineExpression
+      });
+      scope.set(varName, parser2);
+    }
+  }
+  if (replacements.length === 0) return null;
+  for (const imp of macroImports) {
+    imp.fullyResolved = !anyUnresolved;
+  }
+  const ms = new import_magic_string.default(code);
+  for (const imp of macroImports) {
+    if (imp.fullyResolved) {
+      ms.remove(imp.start, imp.end);
+    } else {
+      const original = code.slice(imp.start, imp.end);
+      const stripped = original.replace(/\s+with\s*\{[^}]*\}/gs, "").replace(/\s+assert\s*\{[^}]*\}/gs, "");
+      ms.overwrite(imp.start, imp.end, stripped);
+    }
+  }
+  for (const { start, end, replacement } of [...replacements].sort((a, b) => b.start - a.start)) {
+    ms.overwrite(start, end, replacement);
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true })
+  };
+}
+//# sourceMappingURL=index.cjs.map