parseman 0.32.0 → 0.33.0

package/dist/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAwBA,OAAO,WAAW,MAAM,cAAc,CAAA;AAmBtC,MAAM,MAAM,uBAAuB,GAAG;IACpC,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;8CAC0C;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;;;AAgSD,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAA;IAC3C,kFAAkF;IAClF,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AA0CD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,aAAa,cAA6B,EAC1C,kBAAkB,UAAQ,EAC1B,QAAQ,UAAQ,EAChB,eAAe,UAAQ,GACtB,oBAAoB,GAAG,IAAI,CAw+B7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAwBA,OAAO,WAAW,MAAM,cAAc,CAAA;AAmBtC,MAAM,MAAM,uBAAuB,GAAG;IACpC,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;8CAC0C;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;;;AAgSD,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAA;IAC3C,kFAAkF;IAClF,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AA0CD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,aAAa,cAA6B,EAC1C,kBAAkB,UAAQ,EAC1B,QAAQ,UAAQ,EAChB,eAAe,UAAQ,GACtB,oBAAoB,GAAG,IAAI,CAwgC7B"}

package/dist/plugin/index.js

@@ -2795,7 +2795,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 = (fs2) => fs2.kind === "any";
@@ -7554,9 +7554,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}`);
@@ -7717,10 +7717,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. */
@@ -7729,21 +7747,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). */
@@ -9161,6 +9196,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const gTrivia = triviaValue ? evaluateExpr(triviaValue, scope, code, []) : void 0;
     const scanSkipValue = optionValue("scanSkip");
     const gScanSkip = scanSkipValue ? evaluateCombinatorArray(scanSkipValue, scope, code) ?? void 0 : void 0;
+    if (gScanSkip) {
+      for (const rule of ruleMap.values()) {
+        if (rule && !rule._meta.isTrivia) {
+          ;
+          rule._meta.grammarScanSkip = gScanSkip;
+        }
+      }
+    }
     return { ruleMap, ...gTrivia ? { trivia: gTrivia } : {}, ...gScanSkip ? { scanSkip: gScanSkip } : {} };
   };
   const compileRulesFactory = (init, label2) => {
@@ -9297,12 +9340,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     return pieces;
   };
-  const localCarried = (rm, label2, composing) => {
+  const localCarried = (rm, label2, composing, scanSkip) => {
     const entries = [...rm];
     const ns = nsFor(label2);
-    const ir = serializeRuleMap(entries);
+    const ir = serializeRuleMap(entries, scanSkip);
     if (ir) return { carried: [{ ns, ir }] };
-    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, recovery });
+    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, recovery });
     return p ? { carried: [p] } : null;
   };
   const argPieces = (arg, label2, composing) => {
@@ -9327,18 +9370,13 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
     }
     if (isRulesCall(arg)) {
-      const rulesArgs = arg.arguments;
-      const a0 = rulesArgs[0];
-      const a1 = rulesArgs[1];
-      const optionsFirst = a0?.type === "ObjectExpression";
-      const factory = optionsFirst ? a1 : a0;
-      const rm = factory ? evaluateParserFactory(factory, scope, code, []) : null;
-      return rm ? localCarried(rm, label2, composing) : null;
+      const evaluated = evaluateRulesFactory(arg, label2);
+      return evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
     }
     if (arg.type === "Identifier") {
       const name = arg.name;
       const rm = localRuleMaps.get(name);
-      if (rm) return localCarried(rm, label2, composing);
+      if (rm) return localCarried(rm, label2, composing, localGrammarScanSkip.get(name));
       const composed = localComposedCarried.get(name);
       if (composed) return { carried: composed };
       const pieces = importedPieces(name);
@@ -9561,9 +9599,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           );
           if (exportPrefix) {
             const ns = nsFor(varName);
-            const pieces = compileLinkable([...compiledRules.ruleMap], ns, { recovery });
+            const pieces = compileLinkable([...compiledRules.ruleMap], ns, {
+              ...compiledRules.scanSkip ? { scanSkip: compiledRules.scanSkip } : {},
+              recovery
+            });
             if (pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
-              const ir = serializeRuleMap([...compiledRules.ruleMap]);
+              const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
               replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
             }
           }