parseman 0.26.1 → 0.26.2

package/dist/plugin/index.js

@@ -6325,6 +6325,34 @@ function evalRuleMapIR(ir) {
     n._def.buildSrc = src;
     return n;
   };
+  const _gch = (items) => {
+    const gateSrcs = [];
+    const arms = items.map((it) => {
+      if (Array.isArray(it)) {
+        const [src, comb] = it;
+        gateSrcs.push(src);
+        let gate;
+        try {
+          gate = (0, eval)(`(${src})`);
+        } catch {
+          gate = () => {
+            throw new Error("IR gate fn not materialized");
+          };
+        }
+        return { gate, combinator: comb };
+      }
+      gateSrcs.push(null);
+      return it;
+    });
+    const c = choice(...arms);
+    const gates = c._def.gates;
+    if (gates && gates.length !== gateSrcs.length) {
+      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`);
+    }
+    ;
+    c._def.gateSrcs = gateSrcs;
+    return c;
+  };
   const fn = new Function(
     "rules",
     "ref",
@@ -6350,6 +6378,7 @@ function evalRuleMapIR(ir) {
     "expect",
     "_tf",
     "_nd",
+    "_gch",
     `return (${ir})`
   );
   const map = fn(
@@ -6376,7 +6405,8 @@ function evalRuleMapIR(ir) {
     field,
     expect,
     _tf,
-    _nd
+    _nd,
+    _gch
   );
   return Object.entries(map);
 }
@@ -6488,8 +6518,16 @@ ${body}
       case "sequence":
         return `sequence(${def.parsers.map(kid).join(", ")})`;
       case "choice": {
-        if (def.gates.some((g) => g !== null)) throw new Unserializable("choice with a gate() has no source");
-        return `choice(${def.parsers.map(kid).join(", ")})`;
+        const gates = def.gates;
+        if (gates.every((g) => g === null)) return `choice(${def.parsers.map(kid).join(", ")})`;
+        const gateSrcs = def.gateSrcs;
+        const items = def.parsers.map((p, i) => {
+          if (gates[i] === null) return kid(p);
+          const src = gateSrcs?.[i];
+          if (src == null) throw new Unserializable("choice gate() has no captured source");
+          return `[${JSON.stringify(src)}, ${kid(p)}]`;
+        });
+        return `_gch([${items.join(", ")}])`;
       }
       case "many":
         return `many(${kid(def.parser)})`;
@@ -6670,6 +6708,48 @@ var { isFinite } = Number;
 registerRegexAnalyzer(firstSetFromRegex);
 
 // src/plugin/evaluator.ts
+function stripTsFromSource(node2, code) {
+  const cuts = [];
+  const walk2 = (n) => {
+    if (!n || typeof n !== "object") return;
+    const rec = n;
+    if (typeof rec.type === "string" && rec.type.startsWith("TS") && typeof rec.start === "number" && typeof rec.end === "number") {
+      const ex = rec.expression;
+      if ((rec.type === "TSAsExpression" || rec.type === "TSSatisfiesExpression" || rec.type === "TSNonNullExpression" || rec.type === "TSInstantiationExpression") && ex && typeof ex.end === "number") {
+        cuts.push([ex.end, rec.end]);
+        walk2(rec.expression);
+        return;
+      }
+      if (rec.type === "TSTypeAssertion" && ex && typeof ex.start === "number") {
+        cuts.push([rec.start, ex.start]);
+        walk2(rec.expression);
+        return;
+      }
+      cuts.push([rec.start, rec.end]);
+      return;
+    }
+    for (const key of Object.keys(rec)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      const v2 = rec[key];
+      if (Array.isArray(v2)) {
+        for (const item of v2) walk2(item);
+      } else if (v2 && typeof v2 === "object") walk2(v2);
+    }
+  };
+  walk2(node2);
+  const start = node2.start;
+  const end = node2.end;
+  if (cuts.length === 0) return code.slice(start, end);
+  cuts.sort((a, b) => a[0] - b[0]);
+  let out = "";
+  let cur = start;
+  for (const [s, e] of cuts) {
+    if (s < cur) continue;
+    out += code.slice(cur, s);
+    cur = e;
+  }
+  return out + code.slice(cur, end);
+}
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
 }
@@ -6945,7 +7025,7 @@ function exprToCombi(node2, scope, code, mfs) {
       if (isGatedArmExpr(argNode)) {
         const parts = gatedArmParts(argNode);
         if (!parts) return null;
-        const gateSrc = code.slice(parts.gate.start, parts.gate.end);
+        const gateSrc = stripTsFromSource(parts.gate, code);
         mfs.push(gateSrc);
         const combi = anyValue(parts.combinator, scope, code, mfs);
         if (!isCombinator(combi)) return null;