parseman 0.60.6 → 0.61.1

package/dist/functional/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/functional/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAQ,MAAM,aAAa,CAAA;AAG1F,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAMrF;;;;;;;;;;;;GAYG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC,GACzE,UAAU,CAAC,OAAO,CAAC,CAAA;AAEvB,MAAM,MAAM,UAAU,GAAG;IACvB;;;;eAIW;IACX,eAAe,CAAC,EAAE;QAChB,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;QACvC,aAAa,CAAC,EAAE;YAAE,KAAK,CAAC,KAAK,EAAE;gBAAE,EAAE,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAC;gBAAC,GAAG,CAAC,EAAE,MAAM,CAAA;aAAE,GAAG,IAAI,CAAA;SAAE,CAAA;KACjL,CAAA;IACD;qFACiF;IACjF,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;IAC7B,uDAAuD;IACvD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAA;IACjB;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;OAIG;IACH,UAAU,CAAC,EAAE;QACX,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KACnC,CAAA;IACD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAA;IACX,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,gGAAgG;IAChG,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B;;;;qEAIiE;IACjE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B,CAAA;AAgbD,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAEvF"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/functional/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAQ,MAAM,aAAa,CAAA;AAG1F,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAMrF;;;;;;;;;;;;GAYG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC,GACzE,UAAU,CAAC,OAAO,CAAC,CAAA;AAEvB,MAAM,MAAM,UAAU,GAAG;IACvB;;;;eAIW;IACX,eAAe,CAAC,EAAE;QAChB,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;QACvC,aAAa,CAAC,EAAE;YAAE,KAAK,CAAC,KAAK,EAAE;gBAAE,EAAE,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAC;gBAAC,GAAG,CAAC,EAAE,MAAM,CAAA;aAAE,GAAG,IAAI,CAAA;SAAE,CAAA;KACjL,CAAA;IACD;qFACiF;IACjF,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;IAC7B,uDAAuD;IACvD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAA;IACjB;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;OAIG;IACH,UAAU,CAAC,EAAE;QACX,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KACnC,CAAA;IACD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAA;IACX,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,gGAAgG;IAChG,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B;;;;qEAIiE;IACjE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B,CAAA;AAkbD,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAEvF"}

package/dist/index.js

@@ -3203,6 +3203,7 @@ function derive(c, seen) {
     case "optional":
     case "many":
     case "oneOrMore":
+    case "sepBy":
     case "transform":
     case "not":
     case "peek":
@@ -3353,7 +3354,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);
@@ -3694,6 +3695,16 @@ function matches(pattern) {
   }
   return { kind: "matches", value: pattern.source, flags: pattern.flags };
 }
+function dispatchMatcher(entry) {
+  switch (entry.kind) {
+    case "startsWith":
+      return startsWith(entry.value);
+    case "endsWith":
+      return endsWith(entry.value);
+    case "matches":
+      return matches(new RegExp(entry.value, entry.flags));
+  }
+}
 function when(key, parser2, opts = {}) {
   const usesRouted = parserUsesRouted(parser2);
   if (isStringMatcher(key)) {
@@ -4348,15 +4359,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;
@@ -4367,22 +4383,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);
@@ -4391,19 +4409,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:
@@ -4433,6 +4438,21 @@ function markUnusedValues(root) {
   visit(resolveRoot2(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/cst/root-trivia-scope.ts
 var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
 function refuseUnclassifiedRootScope(strict) {
@@ -4779,6 +4799,7 @@ function linkRules(recipes, link) {
     }
   });
   const winners = /* @__PURE__ */ new Map();
+  const afterLink2 = [];
   const priorHoles = /* @__PURE__ */ new Map();
   const prior = new Proxy({}, {
     get(_target, key) {
@@ -4791,38 +4812,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];
@@ -5307,8 +5332,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 {
@@ -5621,6 +5652,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]];
@@ -6236,11 +6270,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,
@@ -7649,7 +7684,7 @@ function selectOptionalSuffixLexBody(ir) {
 function reinstallsRuleTrivia(reference, target) {
   return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
 }
-function directTokenBodyParser(parser2, resolve, scope) {
+function directTokenBodyParser(parser2, resolve, scope2) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -7659,7 +7694,7 @@ function directTokenBodyParser(parser2, resolve, 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;
     }
@@ -7916,10 +7951,10 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false, cleared
   }
 }
 function directFixedTokenBody(parser2, resolve) {
-  const scope = { cleared: false };
-  const body = directTokenBodyParser(parser2, resolve, scope);
+  const scope2 = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve, scope2);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope.cleared);
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope2.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve) {
@@ -10776,6 +10811,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
@@ -10808,7 +10849,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:
@@ -10825,55 +10866,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;
@@ -13918,9 +13959,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";
 
@@ -17928,12 +17966,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,"] : [],
@@ -21056,7 +21097,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;
@@ -22510,16 +22551,6 @@ function run2(entry, input, options = {}) {
 }
 
 // src/coverage.ts
-function dispatchMatcher(entry) {
-  switch (entry.kind) {
-    case "startsWith":
-      return startsWith(entry.value);
-    case "endsWith":
-      return endsWith(entry.value);
-    case "matches":
-      return matches(new RegExp(entry.value, entry.flags));
-  }
-}
 function compiledGrammarCoverageDefinitions(grammar) {
   const definitions = grammar[GRAMMAR_COVERAGE_DEFINITIONS];
   if (!Array.isArray(definitions) || definitions.length === 0 || !definitions.every((definition) => typeof definition === "object" && definition !== null && typeof definition.id === "string" && (definition.kind === "rule" || definition.kind === "choice-arm" || definition.kind === "dispatch-arm" || definition.kind === "label"))) {