parseman 0.50.3 → 0.50.5

package/dist/index.js

@@ -35,10 +35,20 @@ function classifyFinalChoice(arms, resolve) {
   }
   return { exclusive, firstSets, nullable: nullable2 };
 }
-function resolveNamedRef(p, resolve) {
+function winnerForRef(p, resolve) {
   if (resolve === void 0) return void 0;
   const name = p._ruleName;
-  return name === void 0 ? void 0 : resolve(name);
+  const w = name === void 0 ? void 0 : resolve(name);
+  if (w === void 0 || w === p) return void 0;
+  let cur = w;
+  for (const seen = /* @__PURE__ */ new Set(); !seen.has(cur); ) {
+    if (cur === p) return void 0;
+    seen.add(cur);
+    const cd = cur._def;
+    if (cd.tag !== "grammar" && cd.tag !== "trivia") return w;
+    cur = cd.parser;
+  }
+  return w;
 }
 function union(a, b) {
   if (a.kind === "any" || b.kind === "any") return { kind: "any" };
@@ -136,13 +146,15 @@ function matchesEmptyBody(p, seen, resolve) {
     case "grammar":
     case "recover":
       return me(d.parser);
-    case "lazy":
+    case "lazy": {
+      const w = winnerForRef(p, resolve);
+      if (w !== void 0) return me(w);
       try {
         return me(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve);
-        return t ? me(t) : true;
+        return true;
       }
+    }
     default:
       return true;
   }
@@ -206,13 +218,15 @@ function firstSetBody(p, seen, resolve) {
     // terminals: no refs, cached set is exact
     case "dispatch":
       return fs(d.selector);
-    case "lazy":
+    case "lazy": {
+      const w = winnerForRef(p, resolve);
+      if (w !== void 0) return fs(w);
       try {
         return fs(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve);
-        return t ? fs(t) : any();
+        return any();
       }
+    }
     case "choice": {
       let out = empty();
       for (const arm of d.parsers) out = union(out, fs(arm));
@@ -8066,7 +8080,7 @@ var Encoder = class {
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
         if (matchesEmpty(d.parser)) return body;
-        const fs = d.parser._meta.firstSet;
+        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver()) : d.parser._meta.firstSet;
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -8180,7 +8194,7 @@ var Encoder = class {
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip);
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
-        const fs = d.parser._meta.firstSet;
+        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver()) : d.parser._meta.firstSet;
         if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
@@ -16972,6 +16986,32 @@ var Serializer = class {
   body(c) {
     return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
+  /**
+   * The child a rule-entry grammar scope should serialize as its body, when that
+   * scope merely WRAPS the rule's own named `lazy` proxy.
+   *
+   * `rules({ trackLines: true }, …)` wraps every rule VALUE — which is that rule's
+   * own named lazy proxy — in a `grammarParser({ trackLines: true })` scope
+   * (`parser.ts:229-242`). `body()` unwraps a BARE lazy entry to its defined target;
+   * a lazy wrapped one level deep by that scope must be unwrapped INSIDE the scope
+   * too. Left wrapped, the inner proxy serializes as a `g[name]` SELF-reference and
+   * the rule's real body is dropped, so it re-lowers to `Name: parser(opts, g.Name)`
+   * — a bodyless self-cycle the table encoder rejects with `alias cycle — lazy (rule
+   * 'Name') encodes to its own recursion trampoline`. This is why the four
+   * `*PositionsGrammar` exports fell back to a runtime `compose()` under trackLines.
+   *
+   * STRICT: only a scope that IS a rule entry (in `localRuleNames`) AND wraps ITS
+   * OWN name unwraps. A scope wrapping another rule's ref (a genuine cross-rule
+   * alias, `Name: parser(opts, g.Other)`) or a real body is untouched, so the
+   * non-trackLines and non-self-wrap output stays byte-identical.
+   */
+  scopeSelfBody(c) {
+    const name = this.localRuleNames.get(c);
+    if (name === void 0 || c._def.tag !== "grammar") return void 0;
+    const inner = c._def.parser;
+    if (inner._def.tag !== "lazy" || ruleNameOf4(inner) !== name) return void 0;
+    return lazyTarget(inner) ?? void 0;
+  }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
     for (const c of this.scanSkip) {
@@ -17041,7 +17081,9 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       return;
     }
     active.add(c);
-    for (const child of childrenOf3(def)) this.analyze(child, active);
+    const selfBody = def.tag === "grammar" ? this.scopeSelfBody(c) : void 0;
+    const kids = selfBody === void 0 ? childrenOf3(def) : def.tag === "grammar" && def.triviaParser ? [selfBody, def.triviaParser] : [selfBody];
+    for (const child of kids) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -17207,7 +17249,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         const spec = classified && def.triviaParser ? analyzeLabeledTrivia(def.triviaParser) : null;
         if (classified && !spec) throw new Unserializable("classified trivia without labeled arms");
         const trivia2 = def.clearTrivia ? "null" : spec ? `classifiedTrivia({ ${spec.arms.map((arm) => `${JSON.stringify(arm.label)}: ${kid(arm.parser)}`).join(", ")} })` : def.triviaParser ? kid(def.triviaParser) : "undefined";
-        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
+        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(this.scopeSelfBody(c) ?? def.parser)})`;
       }
       case "withCtx": {
         if (def.extraSrc === void 0) throw new Unserializable("withCtx without extraSrc");
@@ -17343,7 +17385,7 @@ function compileRuleMap(ruleMap, opts = {}) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.50.3";
+var PARSEMAN_VERSION = "0.50.5";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {