parseman 0.32.0 → 0.33.0

package/dist/index.js

@@ -2821,7 +2821,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.32.0";
+var PARSEMAN_VERSION = "0.33.0";
 
 // src/analysis/gating.ts
 var isAny = (fs) => fs.kind === "any";
@@ -7455,9 +7455,9 @@ function lazyTarget(c) {
 }
 var Unserializable = class extends Error {
 };
-function serializeRuleMap(ruleMap) {
+function serializeRuleMap(ruleMap, scanSkip) {
   try {
-    return new Serializer(ruleMap).run();
+    return new Serializer(ruleMap, scanSkip ?? []).run();
   } catch (e) {
     if (e instanceof Unserializable) {
       if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
@@ -7618,10 +7618,28 @@ var Serializer = class {
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
   ruleMap;
-  constructor(ruleMap) {
+  scanSkip;
+  constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
+    this.scanSkip = scanSkip;
     for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
   }
+  /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
+   * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
+   * serialized `scanSkip` array sits in the `rules({ scanSkip })` OPTIONS position,
+   * outside the `(g) => …` factory where `g` is bound. A unit that does reference a
+   * rule can't be carried in options; bail to the full-pieces fallback. */
+  assertNoRuleRef(c, seen) {
+    if (seen.has(c)) return;
+    seen.add(c);
+    if (c._def.tag === "lazy") {
+      if (ruleNameOf2(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      const target = lazyTarget(c);
+      if (target) this.assertNoRuleRef(target, seen);
+      return;
+    }
+    for (const child of childrenOf2(c._def)) this.assertNoRuleRef(child, seen);
+  }
   /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
@@ -7630,21 +7648,38 @@ var Serializer = class {
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
+    for (const c of this.scanSkip) {
+      this.assertNoRuleRef(c, /* @__PURE__ */ new Set());
+      this.analyze(c, /* @__PURE__ */ new Set());
+    }
     let n = 0;
     for (const [c, count] of this.counts) {
       if (this.ruleValues.has(c)) continue;
       if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`);
     }
+    const outerDecls = [];
+    const innerDecls = [];
+    let optionsArg = "";
+    if (this.scanSkip.length > 0) {
+      this.decls = outerDecls;
+      const units = this.scanSkip.map((c) => this.ref(c, null));
+      optionsArg = `{ scanSkip: [${units.join(", ")}] }, `;
+    }
+    this.decls = innerDecls;
     const body = this.ruleMap.map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`).join(",\n");
-    if (this.decls.length === 0) return `rules((g) => ({
+    const factory = innerDecls.length === 0 ? `(g) => ({
 ${body}
-}))`;
-    return `rules((g) => {
-${this.decls.map((d) => "  " + d).join("\n")}
+})` : `(g) => {
+${innerDecls.map((d) => "  " + d).join("\n")}
   return ({
 ${body}
 })
-})`;
+}`;
+    const call = `rules(${optionsArg}${factory})`;
+    return outerDecls.length === 0 ? call : `(() => {
+${outerDecls.map((d) => "  " + d).join("\n")}
+  return ${call}
+})()`;
   }
   /** Count identity references and flag self-referential subtrees. `active` is the
    * set of combinators on the current DFS path (to detect a lazy pointing back). */
@@ -7994,7 +8029,8 @@ function itemCarried(item, used, trivia2) {
       return false;
     }
   });
-  const ir = serializeRuleMap(entries);
+  const scanSkip = entries.map(([, val]) => val._meta.grammarScanSkip).find(Boolean);
+  const ir = serializeRuleMap(entries, scanSkip);
   return ir ? [{ ns, ir }] : [linkable(map, ns, trivia2)];
 }
 function composingTriviaOf(items) {