parseman 0.60.4 → 0.60.6

package/dist/index.js

@@ -40,6 +40,12 @@ function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
     case "oneOrMore":
     case "sepBy":
       return true;
+    // A scope that names or clears trivia keeps an outer install out of its body.
+    // Any other inherits, so it falls through at no cost in depth: line tracking
+    // wraps every rule in one, and must not change what this walk sees.
+    case "grammar":
+      if (d.triviaParser || d.clearTrivia) return false;
+      depth++;
     // Transparent wrappers — they add no position, so ask what they wrap.
     case "node":
     case "transform":
@@ -4537,7 +4543,7 @@ function parser(opts, root) {
         ctx.triviaKindLabels = void 0;
       } else if (scopeTrivia !== void 0) {
         ctx.trivia = scopeTrivia;
-        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
+        ctx.triviaKindLabels = scopeLabels;
       }
       if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
       if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
@@ -4713,11 +4719,16 @@ function tagRule(r, key) {
 function isDefinableRef(v) {
   return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
 }
+function priorNameOf(r) {
+  return r._priorOf;
+}
 function ruleNameOf(r) {
   return r._ruleName;
 }
 function isNamedRuleRefForAnotherRule(r, key) {
-  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  if (r._def.tag !== "lazy") return false;
+  if (priorNameOf(r) !== void 0) return true;
+  const name = ruleNameOf(r);
   return name !== void 0 && name !== key;
 }
 var claimedRules = /* @__PURE__ */ new WeakSet();
@@ -4730,6 +4741,20 @@ function ownRule(p, copies) {
   }
   return own;
 }
+var priorUnfilled = (key) => new Error(`compose: prior.${key} is read, but no grammar composed before it defines "${key}"`);
+function priorHole(key) {
+  const unfilled = priorUnfilled(key);
+  const fail = () => {
+    throw unfilled;
+  };
+  return {
+    _tag: "lazy",
+    _meta: { firstSet: any(), canMatchNewline: true, isTrivia: false },
+    _def: { tag: "lazy", thunk: fail },
+    parse: fail,
+    _priorOf: key
+  };
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
@@ -4754,8 +4779,20 @@ function linkRules(recipes, link) {
     }
   });
   const winners = /* @__PURE__ */ new Map();
+  const priorHoles = /* @__PURE__ */ new Map();
+  const prior = new Proxy({}, {
+    get(_target, key) {
+      if (typeof key !== "string") return void 0;
+      const earlier = winners.get(key)?.parser;
+      if (earlier !== void 0) return earlier._def.tag === "node" ? earlier._def.parser : earlier;
+      if (link !== void 0) throw priorUnfilled(key);
+      let hole = priorHoles.get(key);
+      if (hole === void 0) priorHoles.set(key, hole = priorHole(key));
+      return hole;
+    }
+  });
   for (const recipe of recipes) {
-    const definitions = recipe.factory(proxy);
+    const definitions = recipe.factory(proxy, prior);
     for (const key of Object.keys(definitions)) {
       winners.set(key, { parser: definitions[key], options: recipe.options });
     }
@@ -7304,7 +7341,8 @@ function classifyRuleMap(ruleMap) {
         resolved = void 0;
       }
       if (resolved === void 0) {
-        if (p._ruleName) externalRefs.add(p);
+        const hole = p;
+        if (hole._ruleName !== void 0 || hole._priorOf !== void 0) externalRefs.add(p);
         return;
       }
       scanExternal(resolved);
@@ -7486,6 +7524,7 @@ var OP_LIT_CI = 27;
 var OP_LIT_CI_TRACK = 28;
 var OP_TOKEN = 29;
 var OP_SCOPE_CAP = 30;
+var SCOPE_INHERIT = -2;
 var OP_WITHCTX = 31;
 var OP_GUARD = 32;
 var OP_ADJ = 33;
@@ -9518,7 +9557,7 @@ var Encoder = class {
         this.triviaKnown = savedKnown;
         if (d.clearTrivia === true) return this.emit(op, -1, bodyIp, flags);
         if (d.triviaParser === void 0) {
-          return cap || flags !== 0 ? this.emit(op, -1, bodyIp, flags) : bodyIp;
+          return cap ? this.emit(op, SCOPE_INHERIT, bodyIp, flags) : bodyIp;
         }
         return this.emit(op, this.triviaSlot(d.triviaParser), bodyIp, flags);
       }
@@ -10913,7 +10952,7 @@ function transfer(code, ip, at, hostCst) {
   const op = code[ip];
   if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1];
-    const tri = ki < 0 ? TRI_NONE : ki;
+    const tri = ki === SCOPE_INHERIT ? at.tri : ki < 0 ? TRI_NONE : ki;
     const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
     if (tri === at.tri && cap === at.cap) return at;
     return { tri, buf: at.buf, raw: at.raw, cap };
@@ -10987,7 +11026,7 @@ function scanHandoffNeeded(code, ip, labels) {
     if (l.tri === TRI_UNKNOWN) return true;
     const op = code[at];
     if (op === OP_SCAN) return true;
-    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP && code[at + 1] !== SCOPE_INHERIT) continue;
     if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
     kids.length = 0;
     if (!childSlots(code, at, kids)) return true;
@@ -12282,6 +12321,15 @@ return r.value
         const cap = op === OP_SCOPE_CAP;
         const flags = op === OP_SCOPE_PLAIN ? 0 : code[ip + 3];
         const child = link(code[ip + 2]);
+        if (ki === SCOPE_INHERIT) {
+          return `${head}
+const sC=ctx.captureTrivia
+ctx.captureTrivia=true
+const v=${child}(input,pos,ctx)
+ctx.captureTrivia=sC
+return v
+}`;
+        }
         const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
         const tri = ki < 0 ? "undefined" : hoist("tv", `TRIVIA[${ki}]`);
         const lab = ki < 0 ? "undefined" : hoist("tl", `TRIVIA[${ki}]._meta.triviaKindLabels`);
@@ -13871,7 +13919,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.4";
+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";
@@ -15401,6 +15449,16 @@ function assemble(t, prog, cfg) {
       case OP_SCOPE_CAP:
       case OP_SCOPE_PLAIN: {
         const ki = code[ip + 1];
+        if (ki === SCOPE_INHERIT) {
+          const body = link(code[ip + 2]);
+          return (input, pos, ctx) => {
+            const savedCap = ctx.captureTrivia;
+            ctx.captureTrivia = true;
+            const v = body(input, pos, ctx);
+            ctx.captureTrivia = savedCap;
+            return v;
+          };
+        }
         const scopeTrivia = ki < 0 ? void 0 : trivia2[ki];
         const scopeLabels = scopeTrivia?._meta.triviaKindLabels;
         const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? triviaScan[ki] : null;
@@ -18024,7 +18082,7 @@ function buildGrammarPlan(entry, winners) {
   const dispatches = /* @__PURE__ */ new Map();
   const attempts = /* @__PURE__ */ new Map();
   const labels = /* @__PURE__ */ new Map();
-  const rules2 = /* @__PURE__ */ new Map();
+  const rules3 = /* @__PURE__ */ new Map();
   const winnerNames = /* @__PURE__ */ new Map();
   if (winners) {
     for (const [name, winner] of Object.entries(winners)) {
@@ -18058,7 +18116,7 @@ function buildGrammarPlan(entry, winners) {
   const ownRule2 = (parser2, rule) => {
     const id = `rule:${rule}`;
     definitions.set(id, { id, kind: "rule" });
-    rules2.set(parser2, id);
+    rules3.set(parser2, id);
   };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2, path) => {
@@ -18098,7 +18156,7 @@ function buildGrammarPlan(entry, winners) {
     }
     visit(body ?? root, name);
   }
-  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules2 };
+  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules3 };
 }
 
 // src/analysis/duplication.ts
@@ -19891,6 +19949,8 @@ var Serializer = class {
   localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
+  /** Whether any rule reads a `prior.X` hole, so the factory takes `(g, prior)`. */
+  usesPrior = false;
   accessed;
   referenced = /* @__PURE__ */ new Set();
   constructor(ruleMap, scanSkip = [], accessed = []) {
@@ -19911,7 +19971,7 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf4(c) !== void 0 || priorNameOf(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
@@ -19975,9 +20035,10 @@ var Serializer = class {
     for (const name of this.accessed) {
       if (!this.referenced.has(name)) innerDecls.push(`void g[${JSON.stringify(name)}]`);
     }
-    const factory = innerDecls.length === 0 ? `(g) => ({
+    const params = this.usesPrior ? "(g, prior)" : "(g)";
+    const factory = innerDecls.length === 0 ? `${params} => ({
 ${body}
-})` : `(g) => {
+})` : `${params} => {
 ${innerDecls.map((d) => "  " + d).join("\n")}
   return ({
 ${body}
@@ -19994,6 +20055,10 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
+      if (priorNameOf(c) !== void 0) {
+        this.usesPrior = true;
+        return;
+      }
       if (ruleNameOf4(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
@@ -20072,6 +20137,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     }
     switch (def.tag) {
       case "lazy": {
+        const prior = priorNameOf(c);
+        if (prior !== void 0) return `prior[${JSON.stringify(prior)}]`;
         const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
         if (name !== void 0) {
           this.referenced.add(name);
@@ -20252,7 +20319,8 @@ function externalNames(ruleMap) {
         resolved = void 0;
       }
       if (resolved === void 0) {
-        const name = p._ruleName;
+        const prior = priorNameOf(p);
+        const name = prior === void 0 ? p._ruleName : `prior.${prior}`;
         if (name !== void 0 && !out.includes(name)) out.push(name);
         return;
       }
@@ -20345,9 +20413,9 @@ function carriedRuleMapsDetailed(carried) {
   const maps = [];
   const opaque = [];
   for (const p of carried) {
-    const rules2 = ruleMapOfCarried(p);
-    if (rules2 !== void 0) {
-      maps.push(rules2);
+    const rules3 = ruleMapOfCarried(p);
+    if (rules3 !== void 0) {
+      maps.push(rules3);
       continue;
     }
     opaque.push({ ns: p.ns, ruleNames: isIRPiece(p) ? [] : [...p.keys] });
@@ -20358,7 +20426,7 @@ function recoverComposedRules(grammar) {
   const carried = composedPiecesOf(grammar);
   if (carried === void 0) return void 0;
   const { maps, opaque } = carriedRuleMapsDetailed(carried);
-  const rules2 = /* @__PURE__ */ new Map();
+  const rules3 = /* @__PURE__ */ new Map();
   for (const map of maps) for (const [name, rule] of map) {
     if (rule._def.tag === "lazy") {
       try {
@@ -20367,9 +20435,9 @@ function recoverComposedRules(grammar) {
         continue;
       }
     }
-    rules2.set(name, rule);
+    rules3.set(name, rule);
   }
-  return { rules: rules2, opaque };
+  return { rules: rules3, opaque };
 }
 function composedCoverageRules(grammar) {
   const link = grammar[LINKED];
@@ -21282,12 +21350,12 @@ function inSet(code, fs) {
 var TERMINAL_TAGS = /* @__PURE__ */ new Set(["literal", "regex", "keywords", "scanTo"]);
 var INSTRUMENTABLE = /* @__PURE__ */ new Set(["firstMatch", "sharedPrefix"]);
 function profileWastedWork(opts) {
-  const { rules: rules2, corpus } = opts;
-  const { walked, unresolvedRoots } = walkRules(rules2);
-  const entryParser = typeof opts.entry === "string" ? rules2.find(([n]) => n === opts.entry)?.[1] : opts.entry;
+  const { rules: rules3, corpus } = opts;
+  const { walked, unresolvedRoots } = walkRules(rules3);
+  const entryParser = typeof opts.entry === "string" ? rules3.find(([n]) => n === opts.entry)?.[1] : opts.entry;
   if (entryParser === void 0) {
     throw new TypeError(
-      `choice-cost: entry rule '${String(opts.entry)}' is not in the rule map (have: ${rules2.map(([n]) => n).slice(0, 12).join(", ")}${rules2.length > 12 ? ", \u2026" : ""}).`
+      `choice-cost: entry rule '${String(opts.entry)}' is not in the rule map (have: ${rules3.map(([n]) => n).slice(0, 12).join(", ")}${rules3.length > 12 ? ", \u2026" : ""}).`
     );
   }
   if (corpus.length === 0) {