parseman 0.26.1 → 0.26.3

package/dist/index.js

@@ -5547,7 +5547,7 @@ function emitDispatch(p, ctx, pos) {
         ctx.indent = 1;
         ctx.failLabel = "_pfail";
         ctx.recordFail = true;
-        const innerR = emit(innerParser, ctx, "_pos");
+        const innerR = emitDispatch(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
         ctx.failLabel = savedFailLabel;
         ctx.recordFail = savedRecord;
@@ -6179,6 +6179,23 @@ function escapeClassChar(ch) {
   return ch.replace(/[\\\]^-]/g, "\\$&");
 }
 
+// src/combinators/withCtx.ts
+function withCtx(extra, combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "withCtx",
+    _meta: meta,
+    _def: { tag: "withCtx", extra, parser: combinator },
+    parse(input, pos, ctx) {
+      return combinator.parse(input, pos, { ...ctx, state: extra });
+    }
+  };
+}
+
 // src/compiler/ir-serialize.ts
 function childrenOf2(def) {
   switch (def.tag) {
@@ -6195,6 +6212,7 @@ function childrenOf2(def) {
     case "field":
     case "not":
     case "node":
+    case "withCtx":
     case "expect":
       return [def.parser];
     case "grammar":
@@ -6210,7 +6228,6 @@ function childrenOf2(def) {
     case "regex":
     case "keywords":
     case "guard":
-    case "withCtx":
     case "recover":
     case "unknown":
       return [];
@@ -6257,6 +6274,45 @@ 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 _wc = (src, inner) => {
+    let extra;
+    try {
+      extra = (0, eval)(`(${src})`);
+    } catch {
+      extra = void 0;
+    }
+    const w = withCtx(extra, inner);
+    w._def.extraSrc = src;
+    return w;
+  };
   const fn = new Function(
     "rules",
     "ref",
@@ -6282,6 +6338,8 @@ function evalRuleMapIR(ir) {
     "expect",
     "_tf",
     "_nd",
+    "_gch",
+    "_wc",
     `return (${ir})`
   );
   const map = fn(
@@ -6308,7 +6366,9 @@ function evalRuleMapIR(ir) {
     field,
     expect,
     _tf,
-    _nd
+    _nd,
+    _gch,
+    _wc
   );
   return Object.entries(map);
 }
@@ -6364,7 +6424,7 @@ ${body}
       this.analyze(target, active);
       return;
     }
-    if (def.tag === "guard" || def.tag === "withCtx" || def.tag === "recover" || def.tag === "unknown") {
+    if (def.tag === "guard" || def.tag === "recover" || def.tag === "unknown") {
       throw new Unserializable(`unsupported tag ${def.tag}`);
     }
     this.counts.set(c, (this.counts.get(c) ?? 0) + 1);
@@ -6420,8 +6480,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)})`;
@@ -6465,8 +6533,11 @@ ${body}
         const trivia2 = def.clearTrivia ? "null" : def.triviaParser ? kid(def.triviaParser) : "undefined";
         return `parser({ trivia: ${trivia2}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
       }
+      case "withCtx": {
+        if (def.extraSrc === void 0) throw new Unserializable("withCtx without extraSrc");
+        return `_wc(${JSON.stringify(def.extraSrc)}, ${kid(def.parser)})`;
+      }
       case "guard":
-      case "withCtx":
       case "recover":
       case "unknown":
         throw new Unserializable(`unsupported tag ${def.tag}`);
@@ -6640,23 +6711,6 @@ function guard(predicate) {
   };
 }
 
-// src/combinators/withCtx.ts
-function withCtx(extra, combinator) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "withCtx",
-    _meta: meta,
-    _def: { tag: "withCtx", extra, parser: combinator },
-    parse(input, pos, ctx) {
-      return combinator.parse(input, pos, { ...ctx, state: extra });
-    }
-  };
-}
-
 // src/combinators/completions.ts
 function completionsAt(target, input, offset, options = {}) {
   const probe = { offset, best: null };