parseman 0.55.1 → 0.55.3

package/dist/table/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/table/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAuB,MAAM,aAAa,CAAA;AAyBhF,OAAO,KAAK,EAAmE,YAAY,EAAc,MAAM,cAAc,CAAA;AAS7H,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AA0B9E,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,YAAY,GAAG,EAAE,MAAM,EAAqE;CAC7F;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC,CAAA;AA2wDD,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAEd;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,CA+BnD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/table/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAuB,MAAM,aAAa,CAAA;AAyBhF,OAAO,KAAK,EAAmE,YAAY,EAAc,MAAM,cAAc,CAAA;AAS7H,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AA0B9E,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,YAAY,GAAG,EAAE,MAAM,EAAqE;CAC7F;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC,CAAA;AA4tDD,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAEd;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,CA+BnD"}

package/dist/table/index.js

@@ -2800,14 +2800,8 @@ function choice(...args) {
           if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
-        return {
-          ok: false,
-          expected: parsers.flatMap((p) => {
-            const r = p.parse(input, pos, ctx);
-            return r.ok ? [] : r.expected;
-          }),
-          span: { start: pos, end: pos }
-        };
+        if (ctx._probe !== void 0 || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx);
+        return { ok: false, expected: [...scalarExpected], span: { start: pos, end: pos } };
       }
       if (strategy?.tag === "greedyClassify") {
         const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
@@ -11952,19 +11946,22 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
-function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
-  if (seen.has(p)) return false;
-  seen.add(p);
+function mayCommitFailure(p, resolve, memo = /* @__PURE__ */ new Map()) {
+  return reachesMarked(p, (node) => commitFailureSuccessors(node, resolve), memo);
+}
+var NO_EDGES = [];
+function commitFailureSuccessors(p, resolve) {
   const d = p._def;
   switch (d.tag) {
     case "dispatch":
+    case "unknown":
       return true;
     case "choice":
     case "sequence":
-      return d.parsers.some((x) => mayCommitFailure(x, seen, resolve));
+      return d.parsers;
     // A contained transaction reports every failure uncommitted.
     case "attempt":
-      return d.contain !== true && mayCommitFailure(d.parser, seen, resolve);
+      return d.contain === true ? NO_EDGES : [d.parser];
     case "many":
     case "oneOrMore":
     case "optional":
@@ -11973,31 +11970,77 @@ function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
     case "field":
     case "grammar":
     case "node":
-      return mayCommitFailure(d.parser, seen, resolve);
-    case "sepBy":
-      return mayCommitFailure(d.parser, seen, resolve) || mayCommitFailure(d.separator, seen, resolve);
     case "token":
     case "leaf":
-      return mayCommitFailure(d.parser, seen, resolve);
     case "withCtx":
-      return mayCommitFailure(d.parser, seen, resolve);
+      return [d.parser];
+    case "sepBy":
+      return [d.parser, d.separator];
     case "scanTo":
-      return mayCommitFailure(d.sentinel, seen, resolve) || d.skip.some((x) => mayCommitFailure(x, seen, resolve)) || d.recoverAt !== void 0 && mayCommitFailure(d.recoverAt, seen, resolve) || d.stopAt !== void 0 && mayCommitFailure(d.stopAt, seen, resolve);
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
+        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
+      ];
     case "lazy": {
       try {
-        return mayCommitFailure(d.thunk(), seen, resolve);
+        return [d.thunk()];
       } catch {
         const name = p._ruleName;
         const target = name === void 0 ? void 0 : resolve?.(name);
-        return target === void 0 ? true : mayCommitFailure(target, seen, resolve);
+        return target === void 0 ? true : [target];
       }
     }
-    case "unknown":
-      return true;
     default:
-      return false;
+      return NO_EDGES;
   }
 }
+function reachesMarked(root, successors, memo) {
+  const known = memo.get(root);
+  if (known !== void 0) return known;
+  const order = /* @__PURE__ */ new Map();
+  const low = [];
+  const found = [];
+  const stack = [];
+  const visit = (node) => {
+    const at = low.length;
+    order.set(node, at);
+    low.push(at);
+    found.push(false);
+    stack.push(node);
+    const next = successors(node);
+    if (next === true) found[at] = true;
+    else {
+      for (const child of next) {
+        if (found[at]) break;
+        const hit = memo.get(child);
+        if (hit !== void 0) {
+          if (hit) found[at] = true;
+          continue;
+        }
+        const seen = order.get(child);
+        if (seen !== void 0) {
+          if (seen < low[at]) low[at] = seen;
+          continue;
+        }
+        const k = visit(child);
+        if (low[k] < low[at]) low[at] = low[k];
+        if (found[k]) found[at] = true;
+      }
+    }
+    if (low[at] === at) {
+      const answer = found[at];
+      let member;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node);
+    }
+    return at;
+  };
+  return found[visit(root)];
+}
 
 // src/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
@@ -12428,6 +12471,13 @@ var Encoder = class {
    * attempt sites reach it.
    */
   sideWriterMemo = /* @__PURE__ */ new Map();
+  /**
+   * `mayCommitFailure`'s answers, shared by every choice site for the lifetime
+   * of this `Encoder` — exact for the graph and the `winners` resolver it is
+   * encoding, so the rule graph is walked once per encode rather than once per
+   * choice site.
+   */
+  commitFailureMemo = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -12868,62 +12918,11 @@ var Encoder = class {
   }
   /**
    * Whether a field, recovered error, interpreted scanner or unresolvable shape
-   * is reachable from `root` — the writer census of `failureNeedsRollback`.
-   *
-   * Reachability over a cyclic graph, decided with Tarjan's strongly connected
-   * components so that every node the walk enters leaves with its exact answer
-   * memoized: the members of one component reach each other, so they share one
-   * answer, settled when the walk returns to the component's first node. A DFS
-   * that instead cuts a cycle at its own ancestor path learns nothing it can
-   * keep about a node whose walk hit the cut, and re-walks that node along
-   * every path that reaches it — exponential over recursive value rules (linking
-   * jess's SCSS grammar cost ~290G instructions). This walk enters each node
-   * once per `Encoder`.
+   * is reachable from `root` — the writer census of `failureNeedsRollback`,
+   * entering each combinator once per `Encoder` (see `reachesMarked`).
    */
   reachesSideWriter(root) {
-    const memo = this.sideWriterMemo;
-    const known = memo.get(root);
-    if (known !== void 0) return known;
-    const order = /* @__PURE__ */ new Map();
-    const low = [];
-    const found = [];
-    const stack = [];
-    const visit = (node) => {
-      const at = low.length;
-      order.set(node, at);
-      low.push(at);
-      found.push(false);
-      stack.push(node);
-      const next = this.sideWriterSuccessors(node);
-      if (next === true) found[at] = true;
-      else {
-        for (const child of next) {
-          const hit = memo.get(child);
-          if (hit !== void 0) {
-            if (hit) found[at] = true;
-            continue;
-          }
-          const seen = order.get(child);
-          if (seen !== void 0) {
-            if (seen < low[at]) low[at] = seen;
-            continue;
-          }
-          const k = visit(child);
-          if (low[k] < low[at]) low[at] = low[k];
-          if (found[k]) found[at] = true;
-        }
-      }
-      if (low[at] === at) {
-        const answer = found[at];
-        let member;
-        do {
-          member = stack.pop();
-          memo.set(member, answer);
-        } while (member !== node);
-      }
-      return at;
-    };
-    return found[visit(root)];
+    return reachesMarked(root, (node) => this.sideWriterSuccessors(node), this.sideWriterMemo);
   }
   /** The census's edges out of `node`, or `true` when `node` is itself a writer. */
   sideWriterSuccessors(node) {
@@ -13278,7 +13277,7 @@ var Encoder = class {
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]));
         }
         this.choiceRollbackMasks.set(head, rollbackMask);
-        if (arms.every((arm) => !mayCommitFailure(arm, /* @__PURE__ */ new Set(), rr))) {
+        if (arms.every((arm) => !mayCommitFailure(arm, rr, this.commitFailureMemo))) {
           this.nonCommittingChoiceSites.add(head);
         }
         return head;