parseman 0.61.0 → 0.61.2

package/dist/table/backtrack-probe.d.ts

@@ -0,0 +1,41 @@
+import { type CompactProgram, type TableProgram } from './program.ts';
+import type { RunCfg } from './assemble.ts';
+export type BacktrackCounts = {
+    rewinds: number;
+    bytesReread: number;
+    lookaheads: number;
+    lookaheadBytes: number;
+    regexLookarounds: number;
+    regexLookaroundBytes: number;
+};
+/** Does this pattern read input it does not consume? */
+export declare function hasLookaround(re: RegExp): boolean;
+/**
+ * The counters one probed parse writes. Shared by both table engines and the
+ * interpreter probe, so all three count by the same rule.
+ */
+export declare class BacktrackRecorder {
+    input: string;
+    private counts;
+    private look;
+    private opaque;
+    private last;
+    private furthest;
+    begin(input: string): void;
+    /** The counts for the parse `begin` opened. Throws if a region was left open. */
+    end(): BacktrackCounts;
+    consume(start: number, end: number): void;
+    enterLookahead(): void;
+    exitLookahead(): void;
+    regexAttempt(): void;
+    regexMatch(re: RegExp, start: number, end: number): void;
+    /** A read whose inner steps are not the grammar's (the interpreter's scans). */
+    enterOpaque(): void;
+    exitOpaque(): void;
+}
+export declare function zeroCounts(): BacktrackCounts;
+/** A copy of `source` whose terminals and lookaheads report to `rec`. */
+export declare function probeProgram(source: TableProgram | CompactProgram, rec: BacktrackRecorder): TableProgram;
+/** The option set a probe runs a program under: a plain parse of its host mode. */
+export declare function probeCfg(prog: TableProgram): RunCfg;
+//# sourceMappingURL=backtrack-probe.d.ts.map

package/dist/table/backtrack-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backtrack-probe.d.ts","sourceRoot":"","sources":["../../src/table/backtrack-probe.ts"],"names":[],"mappings":"AAuEA,OAAO,EAC4B,KAAK,cAAc,EAAmB,KAAK,YAAY,EACzF,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;IACxB,oBAAoB,EAAE,MAAM,CAAA;CAC7B,CAAA;AAID,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEjD;AAwBD;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,KAAK,SAAK;IACV,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,QAAQ,CAAI;IAEpB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAOzB;IAED,iFAAiF;IACjF,GAAG,IAAI,eAAe,CAKrB;IAED,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAQxC;IAED,cAAc,IAAI,IAAI,CAGrB;IAED,aAAa,IAAI,IAAI,CAAgB;IAErC,YAAY,IAAI,IAAI,CAEnB;IAED,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAGvD;IAED,gFAAgF;IAChF,WAAW,IAAI,IAAI,CAAkB;IACrC,UAAU,IAAI,IAAI,CAAkB;CACrC;AAED,wBAAgB,UAAU,IAAI,eAAe,CAE5C;AAoBD,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,EAAE,GAAG,EAAE,iBAAiB,GAAG,YAAY,CA2HxG;AAED,mFAAmF;AACnF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAEnD"}

package/dist/table/child-slots.d.ts

@@ -24,5 +24,15 @@
  * report), `site-labels.ts` ignores it (an unwalked site resolves to `TOP` via
  * `labelAt`, and the enclosing assembly is unemittable anyway).
  */
+/**
+ * The child instructions of the row at `ip`, read through `childSlotOffsets` below:
+ * one edge table, two views of it.
+ */
 export declare function childSlots(code: ArrayLike<number>, ip: number, out: number[]): boolean;
+/**
+ * The OPERAND OFFSETS that hold child instructions — the edge table itself. A caller
+ * that rewrites a program's edges (`backtrack-probe.ts`) needs where an edge is
+ * stored, not only where it points.
+ */
+export declare function childSlotOffsets(code: ArrayLike<number>, ip: number, out: number[]): boolean;
 //# sourceMappingURL=child-slots.d.ts.map

package/dist/table/child-slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"child-slots.d.ts","sourceRoot":"","sources":["../../src/table/child-slots.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAiFtF"}
+{"version":3,"file":"child-slots.d.ts","sourceRoot":"","sources":["../../src/table/child-slots.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAKtF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAiF5F"}

package/dist/table/index.js

@@ -3628,7 +3628,7 @@ function regex(pattern, flags = "") {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.61.0";
+var PARSEMAN_VERSION = "0.61.2";
 
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
@@ -6863,6 +6863,12 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
 
 // src/table/child-slots.ts
 function childSlots(code, ip, out) {
+  const from = out.length;
+  if (!childSlotOffsets(code, ip, out)) return false;
+  for (let i = from; i < out.length; i++) out[i] = code[out[i]];
+  return true;
+}
+function childSlotOffsets(code, ip, out) {
   switch (code[ip]) {
     // ZERO-WIDTH / TERMINAL ROWS — no successor. `OP_GUARD` and `OP_ADJ` are both
     // childless tests. `OP_LIVE` holds a hand-written combinator in `prog.fns`; its
@@ -6895,7 +6901,7 @@ function childSlots(code, ip, out) {
     case OP_COV:
     case OP_REJECT:
     case OP_GAPGATE:
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       return true;
     // Single child at `ip + 2`.
     case OP_GATE:
@@ -6912,55 +6918,55 @@ function childSlots(code, ip, out) {
     case OP_ARMGATE:
     case OP_RGATE:
     case OP_RGATE2:
-      out.push(code[ip + 2]);
+      out.push(ip + 2);
       return true;
     // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
     case OP_STRICT:
-      out.push(code[ip + 1], code[ip + 2]);
+      out.push(ip + 1, ip + 2);
       return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
     // data the enclosing `dispatch()` already consumed, so the only edge is the
     // fallback.
     case OP_ROUTED:
-      if (code[ip + 1] >= 0) out.push(code[ip + 1]);
+      if (code[ip + 1] >= 0) out.push(ip + 1);
       return true;
     // `DISPATCH sel d other otherRouted n a1 … an` — the SELECTOR is a child on
     // exactly the same footing as the arms: it runs inside whatever node and scope
     // this site sits in.
     case OP_DISPATCH: {
-      out.push(code[ip + 1]);
-      if (code[ip + 3] >= 0) out.push(code[ip + 3]);
+      out.push(ip + 1);
+      if (code[ip + 3] >= 0) out.push(ip + 3);
       const n = code[ip + 5];
-      for (let i = 0; i < n; i++) out.push(code[ip + 6 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 6 + i);
       return true;
     }
     case OP_SEQ:
     case OP_SEQV: {
       const n = code[ip + 1];
-      for (let i = 0; i < n; i++) out.push(code[ip + 2 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 2 + i);
       return true;
     }
     case OP_SEQX: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 3 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 3 + i);
       return true;
     }
     case OP_CHOICE: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + i);
       return true;
     }
     // Arms are stride-2 from `ip + 4` — the gate word sits beside each arm offset.
     case OP_GREEDY: {
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + 2 * i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + 2 * i);
       return true;
     }
     case OP_REP:
     case OP_REPV:
-      out.push(code[ip + 1]);
-      if (code[ip + 4] >= 0) out.push(code[ip + 4]);
+      out.push(ip + 1);
+      if (code[ip + 4] >= 0) out.push(ip + 4);
       return true;
     default:
       return false;