parseman 0.60.6 → 0.61.0

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);
@@ -4348,15 +4349,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 +4373,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 +4399,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 +4428,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 +4789,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 +4802,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 +5322,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 +5642,9 @@ function sourceLeaf(root, fn) {
   return makeLeaf(root, fn, true);
 }
 
+// src/version.ts
+var PARSEMAN_VERSION = "0.61.0";
+
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
   const raw = constants[spec[0]];
@@ -6236,11 +6260,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 +7674,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 +7684,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 +7941,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) {
@@ -13918,9 +13943,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 +17950,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 +21081,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;