parseman 0.59.0 → 0.59.1

package/dist/analysis/diagnostics.js

@@ -7452,18 +7452,10 @@ var Encoder = class {
   /** TOKEN bodies are an all-program decision. A complete occurrence inside an
    * otherwise incomplete final graph stays on CHARACTER with every sibling. */
   selectLexicalBodies;
-  /**
-   * Decides the extra operands laid down below. ALWAYS TRUE — see
-   * `TableSettings.recovery`. Kept as a field rather than folded away because it
-   * is what every emit site reads, and the emit sites are where the shape of the
-   * row is stated.
-   */
-  rec;
   constructor(settings, selectLexicalBodies) {
     this.settings = settings;
     this.track = settings.trackLines === true;
     this.selectLexicalBodies = selectLexicalBodies;
-    this.rec = true;
     this.plan = settings.coverage;
     this.cov = settings.coverage === void 0 ? void 0 : settings.coverage.definitions.map((d) => [d.id, covKindCode(d.kind)]);
     this.covIndex = new Map((this.cov ?? []).map((d, i) => [d[0], i]));
@@ -7965,12 +7957,10 @@ var Encoder = class {
       }
       case "sequence": {
         const kids = d.parsers.map((c) => this.node(c).ip);
-        const head = this.emitHead(d.valueUnused ? OP_SEQV : OP_SEQ, 1 + kids.length + (this.rec ? kids.length : 0));
+        const head = this.emitHead(d.valueUnused ? OP_SEQV : OP_SEQ, 1 + 2 * kids.length);
         this.code[head + 1] = kids.length;
         for (let i = 0; i < kids.length; i++) this.code[head + 2 + i] = kids[i];
-        if (this.rec) {
-          for (let i = 0; i < kids.length; i++) this.code[head + 2 + kids.length + i] = this.followClass(d.parsers, i);
-        }
+        for (let i = 0; i < kids.length; i++) this.code[head + 2 + kids.length + i] = this.followClass(d.parsers, i);
         return head;
       }
       case "choice": {
@@ -8072,25 +8062,22 @@ var Encoder = class {
         const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
-        return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
+        return this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass);
       }
       case "sepBy": {
         const child = this.node(d.parser).ip;
         const sep = this.node(d.separator).ip;
         const flags = (d.trailing === "allow" ? 1 : 0) | (d.keepSeparators === true ? 2 : 0) | (d.min >= 2 ? 4 : 0);
-        if (this.rec) {
-          return this.emit(
-            OP_REP,
-            child,
-            d.min,
-            d.max ?? -1,
-            sep,
-            flags,
-            this.expected(deriveExpected(d.parser)),
-            this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia))
-          );
-        }
-        return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags);
+        return this.emit(
+          OP_REP,
+          child,
+          d.min,
+          d.max ?? -1,
+          sep,
+          flags,
+          this.expected(deriveExpected(d.parser)),
+          this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia))
+        );
       }
       case "optional": {
         const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
@@ -8101,14 +8088,12 @@ var Encoder = class {
         const inner = d.parser._def;
         if (inner.tag === "sequence" && !this.memo.has(d.parser) && !this.pending.has(d.parser)) {
           const kids = inner.parsers.map((c) => this.node(c).ip);
-          const head = this.emitHead(OP_SEQX, 2 + kids.length + (this.rec ? kids.length : 0));
+          const head = this.emitHead(OP_SEQX, 2 + 2 * kids.length);
           const projection = directArrayProjection(d.fn, d.fnSrc, kids.length);
           this.code[head + 1] = projection === null ? this.fn(d.fn, d.fnSrc ?? null) : ~projection;
           this.code[head + 2] = kids.length;
           for (let i = 0; i < kids.length; i++) this.code[head + 3 + i] = kids[i];
-          if (this.rec) {
-            for (let i = 0; i < kids.length; i++) this.code[head + 3 + kids.length + i] = this.followClass(inner.parsers, i);
-          }
+          for (let i = 0; i < kids.length; i++) this.code[head + 3 + kids.length + i] = this.followClass(inner.parsers, i);
           return head;
         }
         const child = this.node(d.parser).ip;
@@ -8431,7 +8416,7 @@ var Encoder = class {
       ...this.settings.hostMode === void 0 ? {} : { hostMode: this.settings.hostMode },
       ...this.runtimeOnly.size === 0 ? {} : { runtimeOnly: [...this.runtimeOnly].sort() },
       ...this.triviaSpecs.length === 0 ? {} : { triviaSpecs: this.triviaSpecs },
-      ...this.rec ? { rec: 1 } : {},
+      rec: 1,
       ...this.cov === void 0 ? {} : { cov: this.cov },
       lines: this.track ? 1 : 0
     }, void 0, {
@@ -9195,7 +9180,6 @@ function caseFoldLiteralOrAlt(source) {
   }
   return { kind: "alt", arms: litArms, disjoint: false, firsts: litArms.map(() => null) };
 }
-var scanToIndexOfEnabled = () => process.env.PARSEMAN_SCANTO === "indexof";
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
 var litCond = (base, cps, firstVar) => cps.map(
   (cp, k) => k === 0 && firstVar ? `${firstVar} === ${cp}` : `input.charCodeAt(${base}${k ? ` + ${k}` : ""}) === ${cp}`
@@ -9425,13 +9409,7 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
     const j2 = mint("_j");
     const openLen2 = shape.open.length;
     const openChk2 = openLen2 === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
-    const stopCp = shape.stop.length === 1 && shape.stop[0][0] === shape.stop[0][1] ? shape.stop[0][0] : null;
-    const scanLine = stopCp !== null && stopCp <= 65535 && scanToIndexOfEnabled() ? (
-      // No temp is minted: a temp would renumber every later variable in the
-      // function and show up as an artifact-size delta that is counter
-      // renumbering rather than this change (the §9.1.4 / §9.2 effect).
-      `${ind}  ${j2} = input.indexOf(${JSON.stringify(String.fromCharCode(stopCp))}, ${j2}); if (${j2} < 0) ${j2} = input.length`
-    ) : `${ind}  while (${j2} < input.length && !(${classCond(`input.charCodeAt(${j2})`, shape.stop)})) ${j2}++`;
+    const scanLine = `${ind}  while (${j2} < input.length && !(${classCond(`input.charCodeAt(${j2})`, shape.stop)})) ${j2}++`;
     return {
       setup: [
         `${ind}let ${j2} = ${start}`,
@@ -9489,11 +9467,7 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
   const closeLen = shape.close.length;
   const openChk = openLen === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
   const closeChk = litCond(j, shape.close);
-  const closeStr = String.fromCharCode(...shape.close);
-  const scanLines = scanToIndexOfEnabled() ? [
-    `${ind}  ${j} = input.indexOf(${JSON.stringify(closeStr)}, ${j}); if (${j} < 0) ${j} = input.length`,
-    `${ind}  if (${j} + ${closeLen} <= input.length) ${endV} = ${j} + ${closeLen}`
-  ] : [
+  const scanLines = [
     `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
     `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`
   ];
@@ -16409,7 +16383,7 @@ function tableRules(source, metadataOrEntry = {}) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.59.0";
+var PARSEMAN_VERSION = "0.59.1";
 
 // src/table/emit.ts
 var FACTORY_ARITY_GUARD = `if(arguments.length<${EMITTED_PARAMS.length})throw new Error(${JSON.stringify(`parseman: this parser was printed by parseman ${PARSEMAN_VERSION}; upgrade the parseman runtime to at least that version`)});`;