parseman 0.60.6 → 0.61.1

package/dist/plugin/index.js

@@ -500,15 +500,20 @@ function markUnusedValues(root) {
       case "many":
       case "oneOrMore":
         mark(def, consumed);
-        visit(def.parser, consumed);
-        return;
       case "optional":
+      // `optional` returns `inner | null` — no aggregate array/tuple to elide, so
+      // it carries no valueUnused flag. Still descend so an inner many/sequence
+      // under a node() is analyzed (it benefits even when its optional wrapper
+      // doesn't).
+      case "label":
+      case "trivia":
+      case "attempt":
+      case "withCtx":
+      case "expect":
         visit(def.parser, consumed);
         return;
       case "sequence":
         mark(def, consumed);
-        for (const p of def.parsers) visit(p, consumed);
-        return;
       case "choice":
         for (const p of def.parsers) visit(p, consumed);
         return;
@@ -519,22 +524,24 @@ function markUnusedValues(root) {
         if (def.otherwise) visit(def.otherwise, consumed);
         return;
       case "node":
+      // builds from captured children, NOT the inner parser value.
+      case "not":
+      case "peek":
+      // lookahead — value never observed
+      case "token":
         visit(def.parser, false);
         return;
       case "transform":
-        visit(def.parser, true);
-        return;
+      // the map fn reads the value → always consumed.
       case "field":
+      // the field capture records the parsed value → always consumed.
+      case "leaf":
         visit(def.parser, true);
         return;
       case "sepBy":
         visit(def.parser, true);
         visit(def.separator, false);
         return;
-      case "not":
-      case "peek":
-        visit(def.parser, false);
-        return;
       case "grammar":
         visit(def.parser, consumed);
         if (def.triviaParser) visit(def.triviaParser, false);
@@ -543,19 +550,6 @@ function markUnusedValues(root) {
         visit(def.parser, consumed);
         visit(def.sentinel, false);
         return;
-      case "token":
-        visit(def.parser, false);
-        return;
-      case "label":
-      case "trivia":
-      case "attempt":
-      case "withCtx":
-      case "expect":
-        visit(def.parser, consumed);
-        return;
-      case "leaf":
-        visit(def.parser, true);
-        return;
       case "lazy":
         return;
       default:
@@ -585,6 +579,21 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// src/combinators/link-scope.ts
+var scope;
+function afterLink(settle) {
+  scope?.push(settle);
+}
+function collectAfterLink(pending, build) {
+  const outer = scope;
+  scope = outer ?? pending;
+  try {
+    return build();
+  } finally {
+    scope = outer;
+  }
+}
+
 // src/line-index.ts
 import { PlainLineSpan, PlainSpan } from "../cst/plain.js";
 function createLineIndex() {
@@ -1992,6 +2001,7 @@ function linkRules(recipes, link) {
     }
   });
   const winners = /* @__PURE__ */ new Map();
+  const afterLink2 = [];
   const priorHoles = /* @__PURE__ */ new Map();
   const prior = new Proxy({}, {
     get(_target, key) {
@@ -2004,38 +2014,42 @@ function linkRules(recipes, link) {
       return hole;
     }
   });
-  for (const recipe of recipes) {
-    const definitions = recipe.factory(proxy, prior);
-    for (const key of Object.keys(definitions)) {
-      winners.set(key, { parser: definitions[key], options: recipe.options });
-    }
-  }
-  const keys = [...winners.keys()];
   const copies = /* @__PURE__ */ new Map();
-  for (const [key, { parser: defined }] of winners) {
-    const placeholder = cache[key];
-    const parser2 = ownRule(defined, copies);
-    if (placeholder === parser2) {
-      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
-    }
-    if (isDefinableRef(placeholder)) {
-      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
-      placeholder.define(parser2);
-      placeholder._meta.firstSet = parser2._meta.firstSet;
-      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
-    } else if (isNamedRuleRefForAnotherRule(parser2, key) || link !== void 0) {
-      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
-      const alias = ref();
-      tagRule(alias, key);
-      alias.define(parser2);
-      alias._meta.firstSet = parser2._meta.firstSet;
-      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
-      cache[key] = alias;
-    } else {
-      tagRule(parser2, key);
-      cache[key] = parser2;
+  try {
+    for (const recipe of recipes) {
+      const definitions = collectAfterLink(afterLink2, () => recipe.factory(proxy, prior));
+      for (const key of Object.keys(definitions)) {
+        winners.set(key, { parser: definitions[key], options: recipe.options });
+      }
+    }
+    for (const [key, { parser: defined }] of winners) {
+      const placeholder = cache[key];
+      const parser2 = ownRule(defined, copies);
+      if (placeholder === parser2) {
+        throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+      }
+      if (isDefinableRef(placeholder)) {
+        if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
+        placeholder.define(parser2);
+        placeholder._meta.firstSet = parser2._meta.firstSet;
+        placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      } else if (isNamedRuleRefForAnotherRule(parser2, key) || link !== void 0) {
+        if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
+        const alias = ref();
+        tagRule(alias, key);
+        alias.define(parser2);
+        alias._meta.firstSet = parser2._meta.firstSet;
+        alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+        cache[key] = alias;
+      } else {
+        tagRule(parser2, key);
+        cache[key] = parser2;
+      }
     }
+  } finally {
+    for (const settle of afterLink2) settle();
   }
+  const keys = [...winners.keys()];
   for (const key of keys) {
     const options = winners.get(key).options;
     let rule = cache[key];
@@ -3742,6 +3756,7 @@ function derive(c, seen) {
     case "optional":
     case "many":
     case "oneOrMore":
+    case "sepBy":
     case "transform":
     case "not":
     case "peek":
@@ -3889,7 +3904,7 @@ function choice(...args) {
           const result = parsers[idx].parse(input, pos, ctx);
           if (result.ok) return result;
           expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
         if (ctx._probe !== void 0 || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx);
@@ -5283,8 +5298,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const readsState = build ? buildReadsState(def) : project === void 0;
-  const hasOwnFields = parserHasOwnFields(combinator);
-  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+  let hasOwnFields = parserHasOwnFields(combinator);
+  let capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+  if (!hasOwnFields) {
+    afterLink(() => {
+      hasOwnFields = parserHasOwnFields(combinator);
+      capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+    });
+  }
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   let failExpected;
   return {
@@ -5597,6 +5618,9 @@ function sourceLeaf(root, fn) {
   return makeLeaf(root, fn, true);
 }
 
+// src/version.ts
+var PARSEMAN_VERSION = "0.61.1";
+
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
   const raw = constants[spec[0]];
@@ -6212,11 +6236,12 @@ function assemblyExtraIps(prog) {
 }
 function expandCompact(p) {
   if ("code" in p) return p;
+  if (p.es === void 0) throw new Error(`parseman: this parser was printed by an earlier parseman; reprint it with parseman ${PARSEMAN_VERSION}`);
   return ownTableProgram({
     code: p.c,
     k: p.k,
     cc: p.x,
-    fx: p.e,
+    fx: p.e.map((set) => set.map((i) => p.es[i])),
     disp: p.d,
     rules: p.r,
     fns: p.f,
@@ -7279,7 +7304,7 @@ function selectOptionalSuffixLexBody(ir) {
 function reinstallsRuleTrivia(reference, target) {
   return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
 }
-function directTokenBodyParser(parser2, resolve3, scope) {
+function directTokenBodyParser(parser2, resolve3, scope2) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -7289,7 +7314,7 @@ function directTokenBodyParser(parser2, resolve3, scope) {
     const wrapper = body._def;
     if (wrapper.tag === "grammar") {
       if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
-      if (scope !== void 0) scope.cleared = true;
+      if (scope2 !== void 0) scope2.cleared = true;
       body = wrapper.parser;
       continue;
     }
@@ -7546,10 +7571,10 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false, cleared
   }
 }
 function directFixedTokenBody(parser2, resolve3) {
-  const scope = { cleared: false };
-  const body = directTokenBodyParser(parser2, resolve3, scope);
+  const scope2 = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve3, scope2);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set(), false, scope.cleared);
+  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set(), false, scope2.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve3) {
@@ -10403,6 +10428,12 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
 
 // src/table/child-slots.ts
 function childSlots(code, ip, out) {
+  const from = out.length;
+  if (!childSlotOffsets(code, ip, out)) return false;
+  for (let i = from; i < out.length; i++) out[i] = code[out[i]];
+  return true;
+}
+function childSlotOffsets(code, ip, out) {
   switch (code[ip]) {
     // ZERO-WIDTH / TERMINAL ROWS — no successor. `OP_GUARD` and `OP_ADJ` are both
     // childless tests. `OP_LIVE` holds a hand-written combinator in `prog.fns`; its
@@ -10435,7 +10466,7 @@ function childSlots(code, ip, out) {
     case OP_COV:
     case OP_REJECT:
     case OP_GAPGATE:
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       return true;
     // Single child at `ip + 2`.
     case OP_GATE:
@@ -10452,55 +10483,55 @@ function childSlots(code, ip, out) {
     case OP_ARMGATE:
     case OP_RGATE:
     case OP_RGATE2:
-      out.push(code[ip + 2]);
+      out.push(ip + 2);
       return true;
     // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
     case OP_STRICT:
-      out.push(code[ip + 1], code[ip + 2]);
+      out.push(ip + 1, ip + 2);
       return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
     // data the enclosing `dispatch()` already consumed, so the only edge is the
     // fallback.
     case OP_ROUTED:
-      if (code[ip + 1] >= 0) out.push(code[ip + 1]);
+      if (code[ip + 1] >= 0) out.push(ip + 1);
       return true;
     // `DISPATCH sel d other otherRouted n a1 … an` — the SELECTOR is a child on
     // exactly the same footing as the arms: it runs inside whatever node and scope
     // this site sits in.
     case OP_DISPATCH: {
-      out.push(code[ip + 1]);
-      if (code[ip + 3] >= 0) out.push(code[ip + 3]);
+      out.push(ip + 1);
+      if (code[ip + 3] >= 0) out.push(ip + 3);
       const n = code[ip + 5];
-      for (let i = 0; i < n; i++) out.push(code[ip + 6 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 6 + i);
       return true;
     }
     case OP_SEQ:
     case OP_SEQV: {
       const n = code[ip + 1];
-      for (let i = 0; i < n; i++) out.push(code[ip + 2 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 2 + i);
       return true;
     }
     case OP_SEQX: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 3 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 3 + i);
       return true;
     }
     case OP_CHOICE: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + i);
       return true;
     }
     // Arms are stride-2 from `ip + 4` — the gate word sits beside each arm offset.
     case OP_GREEDY: {
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + 2 * i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + 2 * i);
       return true;
     }
     case OP_REP:
     case OP_REPV:
-      out.push(code[ip + 1]);
-      if (code[ip + 4] >= 0) out.push(code[ip + 4]);
+      out.push(ip + 1);
+      if (code[ip + 4] >= 0) out.push(ip + 4);
       return true;
     default:
       return false;
@@ -13545,9 +13576,6 @@ function clearOf(ranges, input, from, to) {
   return true;
 }
 
-// src/version.ts
-var PARSEMAN_VERSION = "0.60.6";
-
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
 
@@ -17566,12 +17594,15 @@ function assertPrintable(prog, who) {
   }
 }
 function programFields(prog, fns, opts = {}) {
+  const tokens = [...new Set(prog.fx.flat())];
+  const tokenAt = new Map(tokens.map((token2, i) => [token2, i]));
   return [
     ...emitAssemblies(prog, opts.assemblies ?? []),
     `c:[${prog.code.join(",")}],`,
     `k:[${prog.k.map(emitConst).join(",")}],`,
     `x:${emitClassPool(prog.cc)},`,
-    `e:[${prog.fx.map((f) => `[${f.map(jsString).join(",")}]`).join(",")}],`,
+    `e:[${prog.fx.map((f) => `[${f.map((token2) => tokenAt.get(token2)).join(",")}]`).join(",")}],`,
+    `es:[${tokens.map(jsString).join(",")}],`,
     `d:[${prog.disp.map((a) => `[${a.join(",")}]`).join(",")}],`,
     `r:${JSON.stringify(prog.rules)},`,
     ...prog.lines === 1 ? ["l:1,"] : [],
@@ -20344,7 +20375,7 @@ function runOnce(entry, input, options) {
   const r = invoke(entry, input, 0, ctx);
   const value = r.ok ? r.value : void 0;
   let span = r.span ?? { start: 0, end: 0 };
-  const expected = r.ok ? [] : r.expected ?? [];
+  const expected = r.ok ? [] : [...new Set(r.expected ?? [])];
   let unconsumedFrom = null;
   if (r.ok) {
     let pos = span.end;
@@ -20757,12 +20788,12 @@ function isWhenFactory(v) {
 function isStaticValueEntry(v) {
   return !!v && typeof v === "object" && "value" in v && "mfSrcs" in v;
 }
-function wordFactoryFromArgs(args, scope, code, mfs) {
+function wordFactoryFromArgs(args, scope2, code, mfs) {
   const [boundaryOrOptsArg, optsArg] = args;
   if (boundaryOrOptsArg?.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
-  const rawBoundaryOrOpts = boundaryOrOptsArg === void 0 ? void 0 : anyValue(boundaryOrOptsArg, scope, code, mfs);
+  const rawBoundaryOrOpts = boundaryOrOptsArg === void 0 ? void 0 : anyValue(boundaryOrOptsArg, scope2, code, mfs);
   const boundaryOrOpts = rawBoundaryOrOpts === void 0 ? "_0-9A-Za-z" : rawBoundaryOrOpts;
-  const opts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs);
+  const opts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope2, code, mfs);
   if (typeof boundaryOrOpts === "string") {
     if (opts !== void 0 && (typeof opts !== "object" || opts === null || Array.isArray(opts))) return null;
     const caseInsensitive2 = typeof opts === "object" && opts !== null && "caseInsensitive" in opts ? opts.caseInsensitive : false;
@@ -20786,10 +20817,10 @@ function dispatchWhenOptions(v) {
   if (typeof caseInsensitive !== "boolean") return null;
   return { caseInsensitive };
 }
-function whenFactoryFromArgs(args, scope, code, mfs) {
+function whenFactoryFromArgs(args, scope2, code, mfs) {
   const [optsArg, extra] = args;
   if (optsArg?.type === "SpreadElement" || extra !== void 0) return null;
-  const rawOpts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs);
+  const rawOpts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope2, code, mfs);
   const opts = dispatchWhenOptions(rawOpts);
   return opts === null ? null : { tag: "whenFactory", caseInsensitive: opts.caseInsensitive ?? false };
 }
@@ -20861,20 +20892,20 @@ function gatedArmParts(e) {
   }
   return gate2 && combinator ? { gate: gate2, combinator } : null;
 }
-function dispatchArmValue(node2, scope, code, mfs) {
+function dispatchArmValue(node2, scope2, code, mfs) {
   if (node2.type === "Identifier") {
-    const value = anyValue(node2, scope, code, mfs);
+    const value = anyValue(node2, scope2, code, mfs);
     return isDispatchArm(value) ? value : null;
   }
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type !== "Identifier") return null;
-  const factory = scope.get(callee.name);
+  const factory = scope2.get(callee.name);
   if (isWhenFactory(factory)) {
     const [keyArg, parserArg, extraArg] = node2.arguments;
     if (!keyArg || !parserArg || extraArg !== void 0 || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
-    const key = anyValue(keyArg, scope, code, mfs);
-    const parserValue = anyValue(parserArg, scope, code, mfs);
+    const key = anyValue(keyArg, scope2, code, mfs);
+    const parserValue = anyValue(parserArg, scope2, code, mfs);
     if (!isCombinator3(parserValue)) return null;
     const opts = { caseInsensitive: factory.caseInsensitive };
     if (typeof key === "string") return when(key, parserValue, opts);
@@ -20885,10 +20916,10 @@ function dispatchArmValue(node2, scope, code, mfs) {
   if (callee.name === "otherwise") {
     const [parserArg, optsArg] = node2.arguments;
     if (!parserArg || parserArg.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
-    const parserValue = anyValue(parserArg, scope, code, mfs);
+    const parserValue = anyValue(parserArg, scope2, code, mfs);
     if (!isCombinator3(parserValue)) return null;
     if (optsArg === void 0) return otherwise(parserValue);
-    const opts = anyValue(optsArg, scope, code, mfs);
+    const opts = anyValue(optsArg, scope2, code, mfs);
     if (typeof opts !== "object" || opts === null) return null;
     const commit = opts.commit;
     if (commit !== void 0 && typeof commit !== "boolean") return null;
@@ -20897,9 +20928,9 @@ function dispatchArmValue(node2, scope, code, mfs) {
   if (callee.name === "when") {
     const [keyArg, parserArg, optsArg] = node2.arguments;
     if (!keyArg || !parserArg || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
-    const key = anyValue(keyArg, scope, code, mfs);
-    const parserValue = anyValue(parserArg, scope, code, mfs);
-    const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs));
+    const key = anyValue(keyArg, scope2, code, mfs);
+    const parserValue = anyValue(parserArg, scope2, code, mfs);
+    const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope2, code, mfs));
     if (opts === null) return null;
     if (!isCombinator3(parserValue)) return null;
     if (typeof key === "string") return when(key, parserValue, opts);
@@ -20926,8 +20957,8 @@ function isDispatchMatcher(v) {
   if ((rec.kind === "startsWith" || rec.kind === "endsWith") && typeof rec.value === "string") return true;
   return rec.kind === "matches" && typeof rec.value === "string" && typeof rec.flags === "string";
 }
-function scopeGet(scope, name, mfs) {
-  const entry = scope.get(name);
+function scopeGet(scope2, name, mfs) {
+  const entry = scope2.get(name);
   if (!entry) return null;
   if (isScopeEntry(entry)) {
     if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
@@ -20948,10 +20979,10 @@ function staticLiteralValue(expr) {
   const val = unwrapStaticExpr(expr);
   return val.type === "Literal" || val.type === "BooleanLiteral" || val.type === "NumericLiteral" ? val.value : void 0;
 }
-function staticStringArray(expr, scope) {
+function staticStringArray(expr, scope2) {
   const id = unwrapStaticExpr(expr);
-  if (id.type === "Identifier" && scope !== void 0 && id.name !== void 0) {
-    const scoped = scope.get(id.name);
+  if (id.type === "Identifier" && scope2 !== void 0 && id.name !== void 0) {
+    const scoped = scope2.get(id.name);
     const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
     return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : void 0;
   }
@@ -20976,11 +21007,11 @@ function staticNodeProject(expr) {
   if (typeof literalValue === "number" || literalValue !== void 0) return { ok: false };
   return { ok: false };
 }
-function scopedStaticValue(expr, scope) {
+function scopedStaticValue(expr, scope2) {
   const unwrapped = unwrapStaticExpr(expr);
   if (unwrapped.type !== "Identifier" || unwrapped.name === "undefined") return { found: false };
-  if (!scope.has(unwrapped.name)) return { found: false };
-  const scoped = scope.get(unwrapped.name);
+  if (!scope2.has(unwrapped.name)) return { found: false };
+  const scoped = scope2.get(unwrapped.name);
   const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
   return { found: true, value };
 }
@@ -21006,9 +21037,9 @@ function staticNodeOptionsFromValue(value) {
   }
   return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 || opts.buildArity !== void 0 ? opts : void 0;
 }
-function staticNodeOptions(expr, scope) {
+function staticNodeOptions(expr, scope2) {
   const unwrapped = unwrapStaticExpr(expr);
-  const scoped = scopedStaticValue(unwrapped, scope);
+  const scoped = scopedStaticValue(unwrapped, scope2);
   if (scoped.found) return staticNodeOptionsFromValue(scoped.value);
   if (unwrapped.type !== "ObjectExpression") return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
@@ -21026,7 +21057,7 @@ function staticNodeOptions(expr, scope) {
       if (project?.ok === false) return STATIC_NODE_OPTIONS_FAILED;
       if (project !== void 0) opts.project = project.value;
     } else if (name === "tags") {
-      const tags = staticStringArray(p.value, scope);
+      const tags = staticStringArray(p.value, scope2);
       if (tags === void 0) return STATIC_NODE_OPTIONS_FAILED;
       opts.tags = tags;
     } else if (name === "buildArity") {
@@ -21038,21 +21069,21 @@ function staticNodeOptions(expr, scope) {
   return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 || opts.buildArity !== void 0 ? opts : void 0;
 }
 var UNKNOWN_OPTIONS = /* @__PURE__ */ Symbol("parseman.unknownOptions");
-function scanOptions(optsArg, scope, code) {
+function scanOptions(optsArg, scope2, code) {
   if (optsArg === void 0) return void 0;
   if (optsArg.type === "SpreadElement") return UNKNOWN_OPTIONS;
-  const opts = anyValue(optsArg, scope, code, []);
-  return isHole(optsArg, opts, scope) ? UNKNOWN_OPTIONS : opts;
+  const opts = anyValue(optsArg, scope2, code, []);
+  return isHole(optsArg, opts, scope2) ? UNKNOWN_OPTIONS : opts;
 }
-function exprToCombi(node2, scope, code, mfs) {
-  if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
+function exprToCombi(node2, scope2, code, mfs) {
+  if (node2.type === "Identifier") return scopeGet(scope2, node2.name, mfs);
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type === "CallExpression" && callee.callee.type === "Identifier" && callee.callee.name === "makeWord") {
     const strArg = node2.arguments[0];
     if (!strArg || strArg.type === "SpreadElement") return null;
-    const factory2 = wordFactoryFromArgs(callee.arguments, scope, code, mfs);
-    const str = anyValue(strArg, scope, code, mfs);
+    const factory2 = wordFactoryFromArgs(callee.arguments, scope2, code, mfs);
+    const str = anyValue(strArg, scope2, code, mfs);
     if (factory2 === null || typeof str !== "string") return null;
     try {
       return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
@@ -21061,11 +21092,11 @@ function exprToCombi(node2, scope, code, mfs) {
     }
   }
   if (callee.type === "Identifier") {
-    const factory2 = scope.get(callee.name);
+    const factory2 = scope2.get(callee.name);
     if (isWordFactory(factory2)) {
       const [strArg] = node2.arguments;
       if (!strArg || strArg.type === "SpreadElement") return null;
-      const str = anyValue(strArg, scope, code, mfs);
+      const str = anyValue(strArg, scope2, code, mfs);
       if (typeof str !== "string") return null;
       try {
         return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
@@ -21078,7 +21109,7 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "transform" && code !== void 0 && mfs !== void 0) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
-    const inner = anyValue(parserArg, scope, code, mfs);
+    const inner = anyValue(parserArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
@@ -21093,7 +21124,7 @@ function exprToCombi(node2, scope, code, mfs) {
   if ((callee.name === "leaf" || callee.name === "sourceLeaf") && code !== void 0 && mfs !== void 0) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
-    const inner = anyValue(parserArg, scope, code, mfs);
+    const inner = anyValue(parserArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
@@ -21108,20 +21139,20 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "node" && code !== void 0) {
     const [firstArg, secondArg, thirdArg, fourthArg] = node2.arguments;
     if (!firstArg || firstArg.type === "SpreadElement") return null;
-    const firstVal = anyValue(firstArg, scope, code, mfs);
+    const firstVal = anyValue(firstArg, scope2, code, mfs);
     const explicitType = typeof firstVal === "string" ? firstVal : void 0;
     const parserArg = explicitType !== void 0 ? secondArg : firstArg;
     const buildArg = explicitType !== void 0 ? thirdArg : secondArg;
     const optsArg = explicitType !== void 0 ? fourthArg : thirdArg;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
-    const inner = anyValue(parserArg, scope, code, mfs);
+    const inner = anyValue(parserArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     const be = buildArg;
     const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
-    const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope2) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
     if (buildArgOptions === STATIC_NODE_OPTIONS_FAILED) return null;
     const buildArgIsOptions = buildArgOptions !== STATIC_NODE_OPTIONS_NOT_OPTIONS;
-    const scopedBuild = buildExpr === void 0 ? { found: false } : scopedStaticValue(buildExpr, scope);
+    const scopedBuild = buildExpr === void 0 ? { found: false } : scopedStaticValue(buildExpr, scope2);
     const absentBuild = buildExpr?.type === "Identifier" && buildExpr.name === "undefined" || buildExpr !== void 0 && staticLiteralValue(buildExpr) === null || scopedBuild.found && (scopedBuild.value === void 0 || scopedBuild.value === null);
     const hasBuild = be !== void 0 && be.type !== "SpreadElement" && !buildArgIsOptions && !absentBuild;
     const buildSrc = hasBuild ? stripTsFromSource(be, code) : void 0;
@@ -21130,7 +21161,7 @@ function exprToCombi(node2, scope, code, mfs) {
       opts = buildArgOptions;
     } else if (optsArg !== void 0) {
       if (optsArg.type === "SpreadElement") return null;
-      const optsResult = staticNodeOptions(optsArg, scope);
+      const optsResult = staticNodeOptions(optsArg, scope2);
       if (optsResult === STATIC_NODE_OPTIONS_FAILED || optsResult === STATIC_NODE_OPTIONS_NOT_OPTIONS) return null;
       opts = optsResult;
     }
@@ -21186,9 +21217,9 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "parser") {
     const [optsArg, rootArg] = node2.arguments;
     if (!optsArg || !rootArg || optsArg.type === "SpreadElement" || rootArg.type === "SpreadElement") return null;
-    const opts = anyValue(optsArg, scope, code, []);
+    const opts = anyValue(optsArg, scope2, code, []);
     if (!opts || typeof opts !== "object") return null;
-    const root = anyValue(rootArg, scope, code, mfs);
+    const root = anyValue(rootArg, scope2, code, mfs);
     if (!isCombinator3(root)) return null;
     try {
       return parser(opts, root);
@@ -21200,15 +21231,15 @@ function exprToCombi(node2, scope, code, mfs) {
     const [itemArg, sepArg, optsArg] = node2.arguments;
     if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
     const itemMfs = [];
-    const itemCombi = anyValue(itemArg, scope, code, itemMfs);
+    const itemCombi = anyValue(itemArg, scope2, code, itemMfs);
     if (!isCombinator3(itemCombi)) return null;
     const sepMfs = [];
-    const sepCombi = anyValue(sepArg, scope, code, sepMfs);
+    const sepCombi = anyValue(sepArg, scope2, code, sepMfs);
     if (!isCombinator3(sepCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
-      const v = anyValue(optsArg, scope, code, []);
+      const v = anyValue(optsArg, scope2, code, []);
       if (!v || typeof v !== "object") return null;
       opts = v;
     }
@@ -21223,12 +21254,12 @@ function exprToCombi(node2, scope, code, mfs) {
     const [itemArg, optsArg] = node2.arguments;
     if (!itemArg || itemArg.type === "SpreadElement") return null;
     const itemMfs = [];
-    const itemCombi = anyValue(itemArg, scope, code, itemMfs);
+    const itemCombi = anyValue(itemArg, scope2, code, itemMfs);
     if (!isCombinator3(itemCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
-      const v = anyValue(optsArg, scope, code, []);
+      const v = anyValue(optsArg, scope2, code, []);
       if (!v || typeof v !== "object") return null;
       opts = v;
     }
@@ -21245,7 +21276,7 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "not") {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
-    const inner = anyValue(innerArg, scope, code, mfs);
+    const inner = anyValue(innerArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     try {
       return not(inner);
@@ -21256,7 +21287,7 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "peek") {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
-    const inner = anyValue(innerArg, scope, code, mfs);
+    const inner = anyValue(innerArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     try {
       return peek(inner);
@@ -21267,10 +21298,10 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "balanced") {
     const [openArg, closeArg, optsArg] = node2.arguments;
     if (!openArg || !closeArg || openArg.type === "SpreadElement" || closeArg.type === "SpreadElement") return null;
-    const open = anyValue(openArg, scope, code, []);
-    const close = anyValue(closeArg, scope, code, []);
+    const open = anyValue(openArg, scope2, code, []);
+    const close = anyValue(closeArg, scope2, code, []);
     if (typeof open !== "string" || typeof close !== "string") return null;
-    const opts = scanOptions(optsArg, scope, code);
+    const opts = scanOptions(optsArg, scope2, code);
     if (opts === UNKNOWN_OPTIONS) return null;
     try {
       return balanced(open, close, opts);
@@ -21281,9 +21312,9 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "scanTo") {
     const [sentinelArg, optsArg] = node2.arguments;
     if (!sentinelArg || sentinelArg.type === "SpreadElement") return null;
-    const sentinel = anyValue(sentinelArg, scope, code, []);
+    const sentinel = anyValue(sentinelArg, scope2, code, []);
     if (!isCombinator3(sentinel)) return null;
-    const opts = scanOptions(optsArg, scope, code);
+    const opts = scanOptions(optsArg, scope2, code);
     if (opts === UNKNOWN_OPTIONS) return null;
     try {
       return scanTo(sentinel, opts);
@@ -21312,12 +21343,12 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!extraArg || !innerArg || extraArg.type === "SpreadElement" || innerArg.type === "SpreadElement") return null;
     const extraSrc = stripTsFromSource(extraArg, code);
     mfs.push(extraSrc);
-    const inner = anyValue(innerArg, scope, code, mfs);
+    const inner = anyValue(innerArg, scope2, code, mfs);
     if (!isCombinator3(inner)) return null;
     try {
       const extraType = unwrapStaticExpr(extraArg).type;
       const derives = extraType === "ArrowFunctionExpression" || extraType === "FunctionExpression";
-      const evaluated = derives ? null : anyValue(extraArg, scope, code, []);
+      const evaluated = derives ? null : anyValue(extraArg, scope2, code, []);
       const usable = typeof evaluated === "object" && evaluated !== null && !Array.isArray(evaluated) && Object.getPrototypeOf(evaluated) === Object.prototype;
       const combi = withCtx(derives ? DERIVE_STAND_IN : usable ? evaluated : UNEVALUATED_EXTRA, inner);
       if (combi._def.tag !== "withCtx") return null;
@@ -21330,12 +21361,12 @@ function exprToCombi(node2, scope, code, mfs) {
   if (callee.name === "dispatch") {
     const [selectorArg, ...armArgs] = node2.arguments;
     if (!selectorArg || selectorArg.type === "SpreadElement") return null;
-    const selector = anyValue(selectorArg, scope, code, mfs);
+    const selector = anyValue(selectorArg, scope2, code, mfs);
     if (!isCombinator3(selector)) return null;
     const arms = [];
     for (const arg of armArgs) {
       if (arg.type === "SpreadElement") return null;
-      const arm = dispatchArmValue(arg, scope, code, mfs);
+      const arm = dispatchArmValue(arg, scope2, code, mfs);
       if (!isDispatchArm(arm)) return null;
       arms.push(arm);
     }
@@ -21357,12 +21388,12 @@ function exprToCombi(node2, scope, code, mfs) {
         if (!parts) return null;
         const gateSrc = stripTsFromSource(parts.gate, code);
         mfs.push(gateSrc);
-        const combi = anyValue(parts.combinator, scope, code, mfs);
+        const combi = anyValue(parts.combinator, scope2, code, mfs);
         if (!isCombinator3(combi)) return null;
         arms.push({ gate: () => true, combinator: combi });
         gateSrcs.push(gateSrc);
       } else {
-        const combi = anyValue(argNode, scope, code, mfs);
+        const combi = anyValue(argNode, scope2, code, mfs);
         if (!isCombinator3(combi)) return null;
         arms.push(combi);
         gateSrcs.push(null);
@@ -21384,7 +21415,7 @@ function exprToCombi(node2, scope, code, mfs) {
   if (!factory) return null;
   const args = node2.arguments.map((arg) => {
     if (arg.type === "SpreadElement") return null;
-    return anyValue(arg, scope, code, mfs);
+    return anyValue(arg, scope2, code, mfs);
   });
   if (args.some((a) => a === null)) return null;
   try {
@@ -21393,16 +21424,16 @@ function exprToCombi(node2, scope, code, mfs) {
     return null;
   }
 }
-function isHole(node2, value, scope) {
+function isHole(node2, value, scope2) {
   if (value !== null) return false;
   const n = unwrapStaticExpr(node2);
-  if (n.type === "Identifier") return !scope.has(n.name);
+  if (n.type === "Identifier") return !scope2.has(n.name);
   return !(n.type === "Literal" && n.value === null) && n.type !== "ArrowFunctionExpression" && n.type !== "FunctionExpression";
 }
-function anyValue(node2, scope, code, mfs) {
+function anyValue(node2, scope2, code, mfs) {
   if (node2.type === "TSAsExpression" || node2.type === "TSSatisfiesExpression" || node2.type === "TSNonNullExpression" || node2.type === "TSTypeAssertion" || node2.type === "TSInstantiationExpression" || node2.type === "ParenthesizedExpression") {
     const inner = node2.expression;
-    return inner ? anyValue(inner, scope, code, mfs) : null;
+    return inner ? anyValue(inner, scope2, code, mfs) : null;
   }
   if (node2.type === "Literal") {
     if ("regex" in node2 && node2.regex !== null && node2.regex !== void 0) {
@@ -21419,8 +21450,8 @@ function anyValue(node2, scope, code, mfs) {
         continue;
       }
       if (el.type === "SpreadElement") return null;
-      const v = anyValue(el, scope, code, mfs);
-      if (isHole(el, v, scope)) return null;
+      const v = anyValue(el, scope2, code, mfs);
+      if (isHole(el, v, scope2)) return null;
       out.push(v);
     }
     return out;
@@ -21431,15 +21462,15 @@ function anyValue(node2, scope, code, mfs) {
       const key = propName(prop);
       if (key === null) return null;
       const valueNode = prop.value;
-      const v = anyValue(valueNode, scope, code, mfs);
-      if (isHole(valueNode, v, scope)) return null;
+      const v = anyValue(valueNode, scope2, code, mfs);
+      if (isHole(valueNode, v, scope2)) return null;
       obj[key] = v;
     }
     return obj;
   }
   if (node2.type === "Identifier") {
     if (node2.name === "undefined") return void 0;
-    const entry = scope.get(node2.name) ?? null;
+    const entry = scope2.get(node2.name) ?? null;
     if (isScopeEntry(entry)) {
       if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
       return entry.combi;
@@ -21452,10 +21483,10 @@ function anyValue(node2, scope, code, mfs) {
   }
   if (node2.type === "MemberExpression") {
     const mem = node2;
-    const obj = anyValue(mem.object, scope, code, mfs);
+    const obj = anyValue(mem.object, scope2, code, mfs);
     if (!obj || typeof obj !== "object") return null;
     if (node2.computed) {
-      const key = anyValue(node2.property, scope, code, mfs);
+      const key = anyValue(node2.property, scope2, code, mfs);
       if (typeof key !== "string" && typeof key !== "number") return null;
       return obj[key] ?? null;
     }
@@ -21466,50 +21497,50 @@ function anyValue(node2, scope, code, mfs) {
   if (node2.type === "CallExpression") {
     const callee = node2.callee;
     if (callee.type === "Identifier" && callee.name === "makeWord") {
-      return wordFactoryFromArgs(node2.arguments, scope, code, mfs);
+      return wordFactoryFromArgs(node2.arguments, scope2, code, mfs);
     }
     if (callee.type === "Identifier" && callee.name === "makeWhen") {
-      return whenFactoryFromArgs(node2.arguments, scope, code, mfs);
+      return whenFactoryFromArgs(node2.arguments, scope2, code, mfs);
     }
     if (callee.type === "Identifier" && (callee.name === "startsWith" || callee.name === "endsWith")) {
       if (node2.arguments.length !== 1 || node2.arguments[0]?.type === "SpreadElement") return null;
-      const value = anyValue(node2.arguments[0], scope, code, mfs);
+      const value = anyValue(node2.arguments[0], scope2, code, mfs);
       if (typeof value !== "string") return null;
       return callee.name === "startsWith" ? startsWith(value) : endsWith(value);
     }
     if (callee.type === "Identifier" && callee.name === "matches") {
       if (node2.arguments.length !== 1 || node2.arguments[0]?.type === "SpreadElement") return null;
-      const value = anyValue(node2.arguments[0], scope, code, mfs);
+      const value = anyValue(node2.arguments[0], scope2, code, mfs);
       if (!(value instanceof RegExp)) return null;
       return matches(value);
     }
     if (callee.type === "Identifier" && (callee.name === "when" || callee.name === "otherwise")) {
-      return dispatchArmValue(node2, scope, code, mfs);
+      return dispatchArmValue(node2, scope2, code, mfs);
     }
-    if (callee.type === "Identifier" && isWhenFactory(scope.get(callee.name))) {
-      return dispatchArmValue(node2, scope, code, mfs);
+    if (callee.type === "Identifier" && isWhenFactory(scope2.get(callee.name))) {
+      return dispatchArmValue(node2, scope2, code, mfs);
     }
-    return exprToCombi(node2, scope, code, mfs);
+    return exprToCombi(node2, scope2, code, mfs);
   }
   return null;
 }
-function evaluateWordFactory(node2, scope, code) {
+function evaluateWordFactory(node2, scope2, code) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type !== "Identifier" || callee.name !== "makeWord") return null;
-  return wordFactoryFromArgs(node2.arguments, scope, code);
+  return wordFactoryFromArgs(node2.arguments, scope2, code);
 }
-function evaluateWhenFactory(node2, scope, code) {
+function evaluateWhenFactory(node2, scope2, code) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type !== "Identifier" || callee.name !== "makeWhen") return null;
-  return whenFactoryFromArgs(node2.arguments, scope, code);
+  return whenFactoryFromArgs(node2.arguments, scope2, code);
 }
-function evaluateExpr(node2, scope, code, mapFnSources) {
-  return exprToCombi(node2, scope, code, mapFnSources);
+function evaluateExpr(node2, scope2, code, mapFnSources) {
+  return exprToCombi(node2, scope2, code, mapFnSources);
 }
-function evaluateCombinatorArray(node2, scope, code) {
-  const val = anyValue(node2, scope, code, []);
+function evaluateCombinatorArray(node2, scope2, code) {
+  const val = anyValue(node2, scope2, code, []);
   if (!Array.isArray(val) || val.length === 0) return null;
   if (!val.every(isCombinator3)) return null;
   return val;
@@ -21523,15 +21554,15 @@ function collectRuleKeys(retObj) {
   }
   return out;
 }
-function evaluateStaticValue(node2, scope, code) {
-  return anyValue(node2, scope, code, []);
+function evaluateStaticValue(node2, scope2, code) {
+  return anyValue(node2, scope2, code, []);
 }
-function flattenRuleEntries(retObj, scope, code) {
+function flattenRuleEntries(retObj, scope2, code) {
   const out = [];
   for (const prop of retObj.properties) {
     const key = propName(prop);
     if (!key) return null;
-    out.push({ key, value: prop.value, scope, code });
+    out.push({ key, value: prop.value, scope: scope2, code });
   }
   return out;
 }
@@ -21549,7 +21580,7 @@ function identifierNamesIn(node2, out = /* @__PURE__ */ new Set()) {
   }
   return out;
 }
-function evalBodyStatements(statements, scope, code, out) {
+function evalBodyStatements(statements, scope2, code, out) {
   const bodyMfs = [];
   const laterNames = [];
   {
@@ -21579,7 +21610,7 @@ function evalBodyStatements(statements, scope, code, out) {
         return false;
       }
       const before = bodyMfs.length;
-      const val = anyValue(decl.init, scope, code, bodyMfs);
+      const val = anyValue(decl.init, scope2, code, bodyMfs);
       if (val === null) {
         if (out) {
           const used = identifierNamesIn(decl.init);
@@ -21589,14 +21620,14 @@ function evalBodyStatements(statements, scope, code, out) {
         return false;
       }
       const thisDeclMfSrcs = bodyMfs.slice(before);
-      if (isCombinator3(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
-      else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
-      else scope.set(name, val);
+      if (isCombinator3(val)) scope2.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      else if (isDispatchArm(val)) scope2.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
+      else scope2.set(name, val);
     }
   }
   return true;
 }
-function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, options) {
+function evaluateParserFactory(factoryNode, scope2, code, mapFnSources, out, options) {
   if (factoryNode.type !== "ArrowFunctionExpression" && factoryNode.type !== "FunctionDeclaration" && factoryNode.type !== "FunctionExpression") return null;
   const factory = factoryNode;
   const params = factory.params;
@@ -21639,7 +21670,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   let built;
   try {
     built = rules(options ?? {}, (g, prior) => {
-      const localScope = scope instanceof ModuleScope ? scope.fork() : new Map(scope);
+      const localScope = scope2 instanceof ModuleScope ? scope2.fork() : new Map(scope2);
       localScope.set(proxyName, g);
       if (priorName !== void 0) localScope.set(priorName, prior);
       if (!evalBodyStatements(statements, localScope, code, out)) throw ABORT;
@@ -21672,16 +21703,16 @@ var externalAccesses = /* @__PURE__ */ new WeakMap();
 function isDefinableRef2(v) {
   return isCombinator3(v) && typeof v.define === "function" && v._def.tag === "lazy";
 }
-function evaluateRefDeclaration(init, name, scope) {
+function evaluateRefDeclaration(init, name, scope2) {
   if (init.type !== "CallExpression") return null;
   const callee = init.callee;
   if (callee.type !== "Identifier" || callee.name !== "ref") return null;
   if (init.arguments.length !== 0) return null;
   const slot = ref();
-  scope.set(name, { combi: slot, mfSrcs: [] });
+  scope2.set(name, { combi: slot, mfSrcs: [] });
   return slot;
 }
-function applyDefineStatement(callExpr, scope, code) {
+function applyDefineStatement(callExpr, scope2, code) {
   if (callExpr.type !== "CallExpression") return false;
   const callee = callExpr.callee;
   if (callee.type !== "MemberExpression") return false;
@@ -21689,12 +21720,12 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.computed) return false;
   if (mem.property.type !== "Identifier" || mem.property.name !== "define") return false;
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
-  const target = scope.get(mem.object.name);
+  const target = scope2.get(mem.object.name);
   const refCombi = isScopeEntry(target) ? target.combi : isCombinator3(target) ? target : null;
   if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
-  const inner = anyValue(args[0], scope, code, []);
+  const inner = anyValue(args[0], scope2, code, []);
   if (!isCombinator3(inner)) return false;
   try {
     refCombi.define(inner);
@@ -21703,17 +21734,17 @@ function applyDefineStatement(callExpr, scope, code) {
   }
   return true;
 }
-function referencesAny(node2, names, scope) {
+function referencesAny(node2, names, scope2) {
   if (node2.type === "Identifier") {
-    return names.has(node2.name) || Map.prototype.has.call(scope, node2.name);
+    return names.has(node2.name) || Map.prototype.has.call(scope2, node2.name);
   }
   for (const key of Object.keys(node2)) {
     const child = node2[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;
+      if (child.some((c) => c && typeof c === "object" && "type" in c && referencesAny(c, names, scope2))) return true;
     } else if ("type" in child) {
-      if (referencesAny(child, names, scope)) return true;
+      if (referencesAny(child, names, scope2)) return true;
     }
   }
   return false;
@@ -21765,30 +21796,30 @@ function patternNames(pat, out) {
       return;
   }
 }
-function declare(scope, name, b) {
-  const prev = scope.bindings.get(name);
+function declare(scope2, name, b) {
+  const prev = scope2.bindings.get(name);
   if (prev) prev.reassigned = true;
-  else scope.bindings.set(name, b);
+  else scope2.bindings.set(name, b);
 }
-function functionScope(scope) {
-  let s = scope;
+function functionScope(scope2) {
+  let s = scope2;
   while (!s.isFunction && s.parent) s = s.parent;
   return s;
 }
 function buildScopeTree(body, moduleEnd) {
   const root = newScope(0, moduleEnd, null, true);
-  const declarePattern = (scope, pat, kind, init) => {
+  const declarePattern = (scope2, pat, kind, init) => {
     const names = [];
     patternNames(pat, names);
-    const target = kind === "var" ? functionScope(scope) : scope;
+    const target = kind === "var" ? functionScope(scope2) : scope2;
     for (const name of names) {
       declare(target, name, init !== void 0 && names.length === 1 ? { kind, init } : { kind });
     }
   };
-  const walk = (n, scope) => {
+  const walk = (n, scope2) => {
     if (!n || typeof n !== "object") return;
     if (Array.isArray(n)) {
-      for (const item of n) walk(item, scope);
+      for (const item of n) walk(item, scope2);
       return;
     }
     const node2 = n;
@@ -21797,15 +21828,15 @@ function buildScopeTree(body, moduleEnd) {
       case "VariableDeclaration": {
         const kind = node2.kind ?? "var";
         for (const d of node2.declarations ?? []) {
-          declarePattern(scope, d.id, kind, d.init ?? void 0);
+          declarePattern(scope2, d.id, kind, d.init ?? void 0);
         }
         break;
       }
       case "FunctionDeclaration":
-        if (node2.id) declare(functionScope(scope), node2.id.name, { kind: "function", init: node2 });
+        if (node2.id) declare(functionScope(scope2), node2.id.name, { kind: "function", init: node2 });
         break;
       case "ClassDeclaration":
-        if (node2.id) declare(scope, node2.id.name, { kind: "class" });
+        if (node2.id) declare(scope2, node2.id.name, { kind: "class" });
         break;
       case "ImportDeclaration": {
         const specifier = node2.source?.value ?? "";
@@ -21813,7 +21844,7 @@ function buildScopeTree(body, moduleEnd) {
           const local = sp.local?.name;
           if (!local) continue;
           const imported = sp.type === "ImportDefaultSpecifier" ? "default" : sp.type === "ImportNamespaceSpecifier" ? "*" : sp.imported?.name ?? local;
-          declare(scope, local, { kind: "import", importRef: { specifier, imported } });
+          declare(scope2, local, { kind: "import", importRef: { specifier, imported } });
         }
         break;
       }
@@ -21822,7 +21853,7 @@ function buildScopeTree(body, moduleEnd) {
     }
     if (SCOPE_TYPES.has(node2.type)) {
       const isFn = FUNCTION_TYPES.has(node2.type);
-      const inner = newScope(node2.start, node2.end, scope, isFn);
+      const inner = newScope(node2.start, node2.end, scope2, isFn);
       if (isFn) {
         for (const p of node2.params ?? []) declarePattern(inner, p, "param");
         if (node2.type === "FunctionExpression" && node2.id) {
@@ -21838,7 +21869,7 @@ function buildScopeTree(body, moduleEnd) {
     }
     for (const key of Object.keys(node2)) {
       if (key === "type" || key === "start" || key === "end") continue;
-      walk(node2[key], scope);
+      walk(node2[key], scope2);
     }
   };
   for (const stmt of body) walk(stmt, root);
@@ -21852,8 +21883,8 @@ function scopeAt(root, offset) {
     cur = next;
   }
 }
-function lookup(scope, name) {
-  for (let s = scope; s; s = s.parent) {
+function lookup(scope2, name) {
+  for (let s = scope2; s; s = s.parent) {
     const b = s.bindings.get(name);
     if (b) return { binding: b, scope: s };
   }
@@ -23579,7 +23610,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
         const stuck = rebaseCarriedBuilderImports(combi2, m.file);
         return stuck ? { unresolved: `has a node() builder reading \`${stuck.local}\` from '${stuck.source}' inside ${m.file}, which this module cannot import \u2014 import it there by package name` } : { value: { combi: combi2, mfSrcs: [] } };
       }
-      const scope2 = moduleValueScope(m);
+      const scope3 = moduleValueScope(m);
       reducerResolver.register(m.file);
       builderImports = (name2) => {
         const b = m.imports.get(name2);
@@ -23587,11 +23618,11 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
         return b && source !== null ? { source, imported: b.imported } : null;
       };
       const mfs = [];
-      const combi = evaluateExpr(init, scope2, m.src, mfs);
+      const combi = evaluateExpr(init, scope3, m.src, mfs);
       if (combi) return { value: { combi, mfSrcs: mfs } };
-      const factory = evaluateWordFactory(init, scope2, m.src) ?? evaluateWhenFactory(init, scope2, m.src);
+      const factory = evaluateWordFactory(init, scope3, m.src) ?? evaluateWhenFactory(init, scope3, m.src);
       if (factory) return { value: factory };
-      const value = evaluateStaticValue(init, scope2, m.src);
+      const value = evaluateStaticValue(init, scope3, m.src);
       if (value !== null && value !== void 0 || isStaticNullishExpression(init)) return { value };
       return {
         unresolved: /\btableRules\b/.test(m.src.slice(init.start, init.end)) ? `is a compiled parser in ${m.file} that carries no combinator IR \u2014 rebuild that module with parseman v${PARSEMAN_VERSION}` : `is not a statically-known combinator or value (${m.file})`
@@ -23632,12 +23663,12 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       }
       return { unresolved: `is not exported by ${m.file}` };
     }
-    const scope2 = moduleValueScope(m);
-    if (!scope2.has(local)) {
-      scope2.get(local);
+    const scope3 = moduleValueScope(m);
+    if (!scope3.has(local)) {
+      scope3.get(local);
       return { unresolved: `could not be resolved in ${m.file}` };
     }
-    return { value: scope2.get(local) };
+    return { value: scope3.get(local) };
   };
   const importedValue = (from, binding) => {
     const file = resolveValueFile(from, binding.source);
@@ -23656,7 +23687,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       deferredLocals.delete(name);
       const outer = [...unresolvedImports];
       unresolvedImports.clear();
-      const value = evaluateStaticValue(deferred, scope, code);
+      const value = evaluateStaticValue(deferred, scope2, code);
       const why = [...unresolvedImports];
       unresolvedImports.clear();
       for (const n of outer) unresolvedImports.add(n);
@@ -23770,7 +23801,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     });
     reducerResolver.register(file);
   }
-  const scope = new ModuleScope(resolveMainFree, unresolvedImports);
+  const scope2 = new ModuleScope(resolveMainFree, unresolvedImports);
   const replacements = [];
   const warnings = [];
   beginDegradationCapture();
@@ -23852,7 +23883,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     const out = evaluate(value);
     if (out === null) {
       const id2 = value.type === "Identifier" ? value.name : null;
-      if (id2 !== null && scope.has(id2) && scope.get(id2) == null) return void 0;
+      if (id2 !== null && scope2.has(id2) && scope2.get(id2) == null) return void 0;
       return unevaluable(value.start, `${label2}: rules({ ${name} })`);
     }
     unresolvedImports.clear();
@@ -23862,7 +23893,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
   const assertPlainOptions = (optExpr, label2) => {
     for (const p of optExpr?.type === "ObjectExpression" ? optExpr.properties : []) {
       if (propName(p) !== null) continue;
-      const key = p.type === "Property" ? evaluateStaticValue(p.key, scope, code) : null;
+      const key = p.type === "Property" ? evaluateStaticValue(p.key, scope2, code) : null;
       if (typeof key !== "string" || RULES_OPTIONS.has(key)) {
         unevaluable(p.start, `${label2}: an options ${p.type === "Property" ? "computed key" : "spread"}`);
       }
@@ -23870,7 +23901,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
   };
   const triviaOption = (optExpr, label2) => {
     assertPlainOptions(optExpr, label2);
-    return requiredOption(label2, "trivia", optionProp(optExpr, "trivia"), (v) => evaluateExpr(v, scope, code, []));
+    return requiredOption(label2, "trivia", optionProp(optExpr, "trivia"), (v) => evaluateExpr(v, scope2, code, []));
   };
   const evaluateRulesFactory = (init, label2) => {
     const args = init.arguments;
@@ -23884,7 +23915,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     }
     const namedFactory = factoryArgRaw.type === "Identifier" ? factoryDecls.get(factoryArgRaw.name) : void 0;
     const factoryArg = namedFactory !== void 0 && namedFactory.declaredAt <= init.start ? namedFactory.fn : factoryArgRaw;
-    const factoryScope = namedFactory?.scope ?? scope;
+    const factoryScope = namedFactory?.scope ?? scope2;
     const factoryCode = namedFactory?.code ?? code;
     const importedFactory = namedFactory?.imported === true && factoryArg === namedFactory.fn ? factoryArgRaw.name : void 0;
     const failedFactory = factoryArgRaw.type === "Identifier" ? factoryFailures.get(factoryArgRaw.name) : void 0;
@@ -23911,9 +23942,9 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     }
     const gTrivia = triviaOption(optionsArg, label2);
     const scanSkipArray = requiredOption(label2, "scanSkip", optionValue("scanSkip"), (v) => {
-      const units = evaluateCombinatorArray(v, scope, code);
+      const units = evaluateCombinatorArray(v, scope2, code);
       if (units) return units;
-      const value = evaluateStaticValue(v, scope, code);
+      const value = evaluateStaticValue(v, scope2, code);
       return Array.isArray(value) && value.length === 0 ? [] : null;
     });
     const gScanSkip = scanSkipArray?.length ? scanSkipArray : void 0;
@@ -24432,7 +24463,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     for (const stmt of body) {
       if (stmt.type === "ExpressionStatement") {
         const expr = stmt.expression;
-        if (applyDefineStatement(expr, scope, code)) {
+        if (applyDefineStatement(expr, scope2, code)) {
           defineRemovals.push({ start: stmt.start, end: stmt.end });
         }
         continue;
@@ -24444,11 +24475,11 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         if (!d.init || d.id.type !== "Identifier") continue;
         const name = d.id.name;
         const init = d.init;
-        if (evaluateRefDeclaration(init, name, scope)) continue;
-        if (scope.has(name)) continue;
-        if (!referencesAny(init, allNames, scope)) continue;
-        const combi = evaluateExpr(init, scope, code, []);
-        if (combi) scope.set(name, { combi, mfSrcs: [] });
+        if (evaluateRefDeclaration(init, name, scope2)) continue;
+        if (scope2.has(name)) continue;
+        if (!referencesAny(init, allNames, scope2)) continue;
+        const combi = evaluateExpr(init, scope2, code, []);
+        if (combi) scope2.set(name, { combi, mfSrcs: [] });
       }
     }
   }
@@ -24474,12 +24505,12 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
       const kind = vd.kind ?? "const";
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
-        if (!referencesAny(init, allNames, scope)) {
+        if (!referencesAny(init, allNames, scope2)) {
           deferredLocals.set(varName, init);
           continue;
         }
         if (refNames.has(varName)) {
-          const refEntry = scope.get(varName);
+          const refEntry = scope2.get(varName);
           const refCombi = refEntry?.combi ?? null;
           if (refCombi) {
             const compiled2 = compile(refCombi, refEntry?.mfSrcs, { recovery, coverage: grammarCoverage });
@@ -24564,32 +24595,32 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         }
         const mapFnSources = [];
         unresolvedImports.clear();
-        const parser2 = evaluateExpr(init, scope, code, mapFnSources);
+        const parser2 = evaluateExpr(init, scope2, code, mapFnSources);
         if (parser2 === null) {
-          const wordFactory = evaluateWordFactory(init, scope, code);
+          const wordFactory = evaluateWordFactory(init, scope2, code);
           if (wordFactory) {
             ;
-            scope.set(varName, wordFactory);
+            scope2.set(varName, wordFactory);
             replacements.push({ start: init.start, end: init.end, replacement: "undefined" });
             continue;
           }
-          const whenFactory = evaluateWhenFactory(init, scope, code);
+          const whenFactory = evaluateWhenFactory(init, scope2, code);
           if (whenFactory) {
             ;
-            scope.set(varName, whenFactory);
+            scope2.set(varName, whenFactory);
             replacements.push({ start: init.start, end: init.end, replacement: "undefined" });
             continue;
           }
-          const combiArray = evaluateCombinatorArray(init, scope, code);
+          const combiArray = evaluateCombinatorArray(init, scope2, code);
           if (combiArray) {
             ;
-            scope.set(varName, combiArray);
+            scope2.set(varName, combiArray);
             continue;
           }
-          const staticValue = evaluateStaticValue(init, scope, code);
+          const staticValue = evaluateStaticValue(init, scope2, code);
           if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
             ;
-            scope.set(varName, staticValue);
+            scope2.set(varName, staticValue);
             continue;
           }
           if (factoryDecls.has(varName)) {
@@ -24612,9 +24643,9 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           replacement: compiled.inlineExpression,
           carry: { name: varName, combi: parser2, exported: exportPrefix !== "" }
         });
-        scope.set(varName, { combi: parser2, mfSrcs: mapFnSources });
+        scope2.set(varName, { combi: parser2, mfSrcs: mapFnSources });
       } else if (d.id.type === "ObjectPattern") {
-        if (!referencesAny(init, allNames, scope)) continue;
+        if (!referencesAny(init, allNames, scope2)) continue;
         if (!isRulesCall(init)) {
           warn(init.start, `destructured macro binding must come from rules(...)`);
           continue;
@@ -24648,7 +24679,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           }
           bindings.push({ ruleKey, localName });
           const rule = compiledRules.ruleMap.get(ruleKey);
-          if (rule) scope.set(localName, { combi: rule, mfSrcs: [] });
+          if (rule) scope2.set(localName, { combi: rule, mfSrcs: [] });
         }
         if (!allOk) continue;
         const holderVar = `__rules${ruleMapHolderCounter++}`;