parseman 0.50.1 → 0.50.4

package/dist/spec/index.js

@@ -1,8 +1,18 @@
 // src/combinators/first-set.ts
-function resolveNamedRef(p, resolve) {
+function winnerForRef(p, resolve) {
   if (resolve === void 0) return void 0;
   const name = p._ruleName;
-  return name === void 0 ? void 0 : resolve(name);
+  const w = name === void 0 ? void 0 : resolve(name);
+  if (w === void 0 || w === p) return void 0;
+  let cur = w;
+  for (const seen = /* @__PURE__ */ new Set(); !seen.has(cur); ) {
+    if (cur === p) return void 0;
+    seen.add(cur);
+    const cd = cur._def;
+    if (cd.tag !== "grammar" && cd.tag !== "trivia") return w;
+    cur = cd.parser;
+  }
+  return w;
 }
 function union(a, b) {
   if (a.kind === "any" || b.kind === "any") return { kind: "any" };
@@ -100,13 +110,15 @@ function matchesEmptyBody(p, seen, resolve) {
     case "grammar":
     case "recover":
       return me(d.parser);
-    case "lazy":
+    case "lazy": {
+      const w = winnerForRef(p, resolve);
+      if (w !== void 0) return me(w);
       try {
         return me(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve);
-        return t ? me(t) : true;
+        return true;
       }
+    }
     default:
       return true;
   }
@@ -170,13 +182,15 @@ function firstSetBody(p, seen, resolve) {
     // terminals: no refs, cached set is exact
     case "dispatch":
       return fs(d.selector);
-    case "lazy":
+    case "lazy": {
+      const w = winnerForRef(p, resolve);
+      if (w !== void 0) return fs(w);
       try {
         return fs(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve);
-        return t ? fs(t) : any();
+        return any();
       }
+    }
     case "choice": {
       let out = empty();
       for (const arm of d.parsers) out = union(out, fs(arm));
@@ -270,9 +284,43 @@ function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
   }
 }
 
+// src/combinators/scalar.ts
+var SCALAR_TAG = /^(?:literal|regex|keywords|sequence|choice|many|oneOrMore|optional|transform|trivia|grammar|sepBy|lazy)$/;
+function scalarOf(combinator) {
+  return combinator._parseScalar;
+}
+function scalarTree(parser2, seen) {
+  if (seen.has(parser2)) return true;
+  if (parser2._parseScalar === void 0) return false;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (!SCALAR_TAG.test(def.tag)) return false;
+  if ("parsers" in def && !def.parsers.every((child) => scalarTree(child, seen))) return false;
+  if ("parser" in def && !scalarTree(def.parser, seen)) return false;
+  if ("separator" in def && !scalarTree(def.separator, seen)) return false;
+  return def.tag !== "lazy" || scalarTree(def.thunk(), seen);
+}
+function scalarRootOf(combinator) {
+  const scalar = combinator._parseScalar;
+  const def = combinator._def;
+  return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
+}
+
 // src/combinators/ref.ts
+function withRuleTrivia(trivia2, ctx, run) {
+  const savedLabels = ctx.triviaKindLabels;
+  ctx.trivia = trivia2;
+  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
+  try {
+    return run();
+  } finally {
+    ctx.trivia = void 0;
+    ctx.triviaKindLabels = savedLabels;
+  }
+}
 function ref() {
   let resolved = null;
+  let resolvedScalar = null;
   let ownBoundary = false;
   const meta = {
     firstSet: any(),
@@ -289,25 +337,28 @@ function ref() {
         return resolved;
       }
     },
+    _parseScalar(input, pos, ctx) {
+      const scalar = resolvedScalar;
+      if (!scalar) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
+      }
+      return scalar(input, pos, ctx);
+    },
     parse(input, pos, ctx) {
-      if (!resolved) throw new Error("ref<T>() used before .define() was called");
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
       const gt = meta.grammarTrivia;
       if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        const savedLabels = ctx.triviaKindLabels;
-        ctx.trivia = gt;
-        ctx.triviaKindLabels = gt._meta.triviaKindLabels;
-        try {
-          return resolved.parse(input, pos, ctx);
-        } finally {
-          ctx.trivia = void 0;
-          ctx.triviaKindLabels = savedLabels;
-        }
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
       }
-      return resolved.parse(input, pos, ctx);
+      return parser2.parse(input, pos, ctx);
     },
     define(p) {
       if (resolved) throw new Error("ref<T>() already defined");
       resolved = p;
+      resolvedScalar = scalarOf(p);
       ownBoundary = hasOwnTriviaBoundary(p);
       meta.firstSet = p._meta.firstSet;
       meta.canMatchNewline = p._meta.canMatchNewline;
@@ -530,7 +581,7 @@ function pushCstLeaf(ctx, leaf2) {
   const annotated = leaf2 && typeof leaf2 === "object" && leaf2.span ? { ...leaf2, span: annotateSpanFromLineContext(leaf2.span, ctx) } : leaf2;
   pushCstChild(ctx, annotated, annotated);
 }
-function pushCstChild(ctx, built, rawEntry2) {
+function pushCstChild(ctx, built, rawEntry) {
   const b = ctx._cstBuf;
   if (b) {
     if (b.rawOnly !== true) {
@@ -541,16 +592,16 @@ function pushCstChild(ctx, built, rawEntry2) {
       } else b.single = built;
     }
     if (b.noRaw === true) b.rawLen = (b.rawLen ?? 0) + 1;
-    else if (b.raw) b.raw.push(rawEntry2);
+    else if (b.raw) b.raw.push(rawEntry);
     else if (b.rawSingle !== void 0) {
-      b.raw = [b.rawSingle, rawEntry2];
+      b.raw = [b.rawSingle, rawEntry];
       b.rawSingle = void 0;
-    } else b.rawSingle = rawEntry2;
+    } else b.rawSingle = rawEntry;
     return;
   }
   if (ctx._cstChildren) ctx._cstChildren.push(built);
   else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
-  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
+  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry);
 }
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
@@ -693,6 +744,7 @@ function createParseContext() {
     _fe: void 0,
     _fx: void 0,
     _fc: void 0,
+    _sv: void 0,
     _probe: void 0,
     _cstChildren: void 0,
     _cstLeaves: void 0,
@@ -1530,6 +1582,24 @@ function parser(opts, root) {
   const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
   const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
   const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
   const grammar = {
     _tag: "grammar",
     _meta: {
@@ -1553,7 +1623,20 @@ function parser(opts, root) {
       constructionTrackLines: trackLinesPolicy,
       ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
     },
+    _parseScalar: parseScalar,
     parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
       if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
       const trackLines = trackLinesOf(_ctx);
       const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
@@ -2146,10 +2229,32 @@ function regex(pattern, flags = "") {
   const canMatchNewline = raw.canMatchNewline;
   const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
   const def = { tag: "regex", source, flags: resolvedFlags };
+  const expected = directTerminalFailureExpected(def);
+  const parseScalar = (input, pos, ctx) => {
+    const scanEnd = scan?.(input, pos);
+    if (scanEnd !== void 0) {
+      if (scanEnd === null) {
+        ctx._fx = expected;
+        return ~pos;
+      }
+      ctx._sv = input.slice(pos, scanEnd);
+      return scanEnd;
+    }
+    anchored.lastIndex = pos;
+    const match = anchored.exec(input);
+    if (match === null) {
+      ctx._fx = expected;
+      return ~pos;
+    }
+    ctx._sv = match[0];
+    return pos + match[0].length;
+  };
   return {
     _tag: "regex",
     _meta: meta,
     _def: def,
+    _stickyRegex: anchored,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       const scanEnd = scan?.(input, pos);
       if (scanEnd !== void 0) {
@@ -2194,6 +2299,28 @@ function literal(value, opts = {}) {
     isTrivia: false
   };
   const canMatchNewline = meta.canMatchNewline;
+  const parseScalar = !caseInsensitive && value.length === 1 ? (() => {
+    const code = value.charCodeAt(0);
+    return (input, pos, ctx) => {
+      if (input.charCodeAt(pos) === code) {
+        ctx._sv = value;
+        return pos + 1;
+      }
+      ctx._fx = expected;
+      return ~pos;
+    };
+  })() : (input, pos, ctx) => {
+    const end = pos + value.length;
+    if (end <= input.length) {
+      const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+      if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+        ctx._sv = matchedValue;
+        return end;
+      }
+    }
+    ctx._fx = expected;
+    return ~pos;
+  };
   if (caseInsensitive) {
     const upper = value.toUpperCase();
     const lower = value.toLowerCase();
@@ -2234,6 +2361,7 @@ function literal(value, opts = {}) {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
+    _parseScalar: parseScalar,
     parse
   };
 }
@@ -2301,16 +2429,26 @@ function keywords(words, opts = {}) {
     caseInsensitive: opts.caseInsensitive ?? false,
     boundary: opts.boundary
   };
+  const expected = directTerminalFailureExpected(def);
+  const parseScalar = (input, pos, ctx) => {
+    re.lastIndex = pos;
+    const m = re.exec(input);
+    if (m === null) {
+      ctx._fx = expected;
+      return ~pos;
+    }
+    ctx._sv = m[0];
+    return pos + m[0].length;
+  };
   return {
     _tag: "keywords",
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       re.lastIndex = pos;
       const m = re.exec(input);
-      if (m === null || m.index !== pos) {
-        return failAt(ctx, directTerminalFailureExpected(def), pos);
-      }
+      if (m === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
       if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
@@ -2341,6 +2479,9 @@ var fastScanner3;
 function needsDeferredTriviaCommit(ctx) {
   return ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
 }
+function needsTriviaRollback(ctx) {
+  return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0;
+}
 function saveTriviaMark(ctx) {
   const m = saveCstMark(ctx);
   return {
@@ -2452,7 +2593,8 @@ function advanceTrivia(input, cur, ctx) {
   const triviaP = ctx.trivia;
   if (!triviaP) return cur;
   if (!ctx.trackLines) {
-    const fast2 = fastTriviaScanner(triviaP);
+    const classified = triviaP._meta.triviaScanner;
+    const fast2 = classified === void 0 ? fastTriviaScanner(triviaP) : classified;
     if (fast2) return fast2(input, cur);
     if (ctx.triviaKindLabels) return skipWithLabels(input, cur, ctx);
     const tr2 = triviaP.parse(input, cur, createDetachedParseContext(ctx.trackLines, ctx.state));
@@ -3043,6 +3185,7 @@ function sequence(...parsers) {
     (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
   }
   const hasAdjacency = adjacency !== null;
+  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
   const meta = {
     // Union through the nullable prefix — a leading optional()/many() lets a later
     // term's first char start the sequence. Just `parsers[0]` under-approximates.
@@ -3051,165 +3194,96 @@ function sequence(...parsers) {
     isTrivia: false
   };
   const def = { tag: "sequence", parsers };
-  let followSentinels;
-  function parseTolerant(input, pos, ctx) {
-    followSentinels ??= parsers.map((_, i) => {
-      const fs = parsers.slice(i + 1).reduce(
-        (acc, p) => union(acc, firstSetOf(p)),
-        { kind: "empty" }
-      );
-      return firstSetSentinel(fs);
-    });
-    const values = def.valueUnused ? void 0 : [];
+  const scalarParsers = parsers.map(scalarOf);
+  const parseScalar = (input, pos, ctx) => {
     let cur = pos;
-    const inheritedSync = ctx._sync;
-    try {
-      for (let i = 0; i < parsers.length; i++) {
-        ctx._sync = followSentinels[i] ?? inheritedSync;
-        const adj = adjacency === null ? null : adjacency[i];
-        if (adj) {
-          if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj);
-          if (values !== void 0) values.push(null);
-          continue;
-        }
-        if (ctx.trivia && i > 0) {
-          const mTlog = cstTlLen(ctx);
-          const mLog = ctx._triviaLog?.length ?? 0;
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-          let scanEnd;
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
-          }
-          const scanTlog = cstTlLen(ctx);
-          const scanLog = ctx._triviaLog?.length ?? 0;
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackScannedTriviaAt(
-            ctx,
-            mTlog,
-            scanTlog,
-            mLog,
-            scanLog,
-            mRootLog,
-            scanRootLog
-          );
-          if (values !== void 0) values.push(result2.value);
-          continue;
-        }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
+    if (strictArity !== 0) {
+      cur = scalarParsers[0](input, cur, ctx);
+      if (cur < 0) return cur;
+      const first = ctx._sv;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[1](input, cur, ctx);
+      if (cur < 0) return cur;
+      const second = ctx._sv;
+      if (strictArity === 2) {
+        ctx._sv = def.valueUnused ? void 0 : [first, second];
+        return cur;
       }
-    } finally {
-      ctx._sync = inheritedSync;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[2](input, cur, ctx);
+      if (cur < 0) return cur;
+      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
+      return cur;
     }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: values ?? void 0,
-      span: { start: pos, end: cur }
-    };
-  }
-  function parseAdjacent(input, pos, ctx) {
     const values = def.valueUnused ? void 0 : [];
-    let cur = pos;
-    for (let i = 0; i < parsers.length; i++) {
-      const adj = adjacency[i];
-      if (adj) {
-        if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj);
-        if (values !== void 0) values.push(null);
-        continue;
-      }
-      if (ctx.trivia && i > 0) {
-        let scanEnd;
-        const mTlog = cstTlLen(ctx);
-        const mLog = ctx._triviaLog?.length ?? 0;
-        const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-        if (needsDeferredTriviaCommit(ctx)) {
-          scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-        } else {
-          scanEnd = advanceTrivia(input, cur, ctx);
-        }
-        const scanTlog = cstTlLen(ctx);
-        const scanLog = ctx._triviaLog?.length ?? 0;
-        const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-        const result2 = parsers[i].parse(input, scanEnd, ctx);
-        if (!result2.ok) return result2;
-        if (result2.span.end > scanEnd) cur = result2.span.end;
-        else rollbackScannedTriviaAt(
-          ctx,
-          mTlog,
-          scanTlog,
-          mLog,
-          scanLog,
-          mRootLog,
-          scanRootLog
-        );
-        if (values !== void 0) values.push(result2.value);
-        continue;
-      }
-      const result = parsers[i].parse(input, cur, ctx);
-      if (!result.ok) return result;
-      if (values !== void 0) values.push(result.value);
-      cur = result.span.end;
-    }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: values ?? void 0,
-      span: { start: pos, end: cur }
-    };
-  }
+    for (let i = 0; i < scalarParsers.length; i++) {
+      let termPos = cur;
+      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
+      const end = scalarParsers[i](input, termPos, ctx);
+      if (end < 0) return end;
+      if (values !== void 0) values.push(ctx._sv);
+      if (end > termPos || termPos === cur) cur = end;
+    }
+    ctx._sv = values;
+    return cur;
+  };
+  let followSentinels;
   return {
     _tag: "sequence",
     _meta: meta,
     _def: def,
+    _parseScalar: hasAdjacency ? void 0 : parseScalar,
     parse(input, pos, ctx) {
-      if (ctx._tolerant) return parseTolerant(input, pos, ctx);
-      if (hasAdjacency) return parseAdjacent(input, pos, ctx);
+      const tolerant = ctx._tolerant === true;
+      if (tolerant) {
+        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
+          parsers.slice(i + 1).reduce(
+            (set, parser2) => union(set, firstSetOf(parser2)),
+            { kind: "empty" }
+          )
+        ));
+      }
+      const inheritedSync = ctx._sync;
+      const deferredTrivia = needsDeferredTriviaCommit(ctx);
       const values = def.valueUnused ? void 0 : [];
       let cur = pos;
-      for (let i = 0; i < parsers.length; i++) {
-        if (ctx.trivia && i > 0) {
-          let scanEnd;
-          const mTlog = cstTlLen(ctx);
-          const mLog = ctx._triviaLog?.length ?? 0;
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
+      try {
+        for (let i = 0; i < parsers.length; i++) {
+          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
+          const assertion = adjacency?.[i];
+          if (assertion) {
+            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
+            if (values !== void 0) values.push(null);
+            continue;
           }
-          const scanTlog = cstTlLen(ctx);
-          const scanLog = ctx._triviaLog?.length ?? 0;
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) {
-            cur = result2.span.end;
-          } else {
+          let termPos = cur;
+          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (ctx.trivia && i > 0) {
+            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
+          }
+          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          const result = parsers[i].parse(input, termPos, ctx);
+          if (!result.ok) return result;
+          if (values !== void 0) values.push(result.value);
+          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
+          else if (deferredTrivia) {
             rollbackScannedTriviaAt(
               ctx,
-              mTlog,
+              markTlog,
               scanTlog,
-              mLog,
+              markLog,
               scanLog,
-              mRootLog,
+              markRootLog,
               scanRootLog
             );
           }
-          if (values !== void 0) values.push(result2.value);
-          continue;
         }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
+      } finally {
+        if (tolerant) ctx._sync = inheritedSync;
       }
       return {
         ok: true,
@@ -3341,7 +3415,8 @@ function choice(...args) {
     disjoint
   };
   const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
+  const ordered = strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix";
+  const autoNot = !disjoint && !hasGates && ordered ? computeAutoNot(parsers) : parsers.map(() => null);
   let greedyLitMap = null;
   let sortedParsers = null;
   const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
@@ -3355,6 +3430,37 @@ function choice(...args) {
   } else if (strategy?.tag === "literalsLongestFirst") {
     sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
   }
+  const scalarParsers = parsers.map(scalarOf);
+  const scalarEligible = !hasGates && parsers.every((p) => p._parseScalar !== void 0) && (disjoint || ordered);
+  const scalarExpected = parsers.flatMap(deriveExpected);
+  const parseScalar = (input, pos, ctx) => {
+    if (disjoint) {
+      const code = pos < input.length ? input.codePointAt(pos) : -1;
+      let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
+      if (idx < 0 && code >= 0) {
+        for (let i = 0; i < parsers.length; i++) {
+          if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+            idx = i;
+            break;
+          }
+        }
+      }
+      if (idx >= 0) {
+        const gate = gates[idx];
+        if (!gate || gate(ctx.state)) return scalarParsers[idx](input, pos, ctx);
+        ctx._fx = deriveExpected(parsers[idx]);
+        return ~pos;
+      }
+    } else {
+      for (let i = 0; i < scalarParsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const end = scalarParsers[i](input, pos, ctx);
+        if (end >= 0 && (!autoNot[i] || !autoNotFires(input, end, autoNot[i]))) return end;
+      }
+    }
+    ctx._fx = scalarExpected;
+    return ~pos;
+  };
   return {
     _tag: "choice",
     _meta: meta,
@@ -3366,6 +3472,7 @@ function choice(...args) {
       strategy: strategy ?? { tag: "firstMatch" },
       autoNot
     },
+    _parseScalar: scalarEligible ? parseScalar : void 0,
     parse(input, pos, ctx) {
       const expected = [];
       let expectedAt = pos;
@@ -3897,8 +4004,8 @@ function attempt(parser2) {
 }
 
 // src/combinators/repeat.ts
-function repItem(combinator, input, cur, ctx, guardable, mandatory) {
-  const mark = saveTriviaMark(ctx);
+function repItem(combinator, input, cur, ctx, guardable, mandatory, rollbackNeeded) {
+  const mark = rollbackNeeded ? saveTriviaMark(ctx) : void 0;
   let pos = cur;
   if (ctx.trivia) {
     if (needsDeferredTriviaCommit(ctx)) {
@@ -3908,24 +4015,24 @@ function repItem(combinator, input, cur, ctx, guardable, mandatory) {
     }
   }
   if (pos >= input.length && !mandatory) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
   if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     if (result.committed) return { fail: result, failPos: pos };
     return { fail: result, failPos: pos };
   }
   if (result.span.end === pos && !mandatory) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
-  return { value: result.value, end: result.span.end };
+  return result;
 }
 function resolveBounds(what, opts) {
   const min = opts.min ?? 0;
@@ -3938,6 +4045,21 @@ function resolveBounds(what, opts) {
   if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
   return { min, max };
 }
+function repeatScalarTail(combinator, child, input, cur, ctx, guardable, values, remaining) {
+  while (cur < input.length && remaining > 0) {
+    let itemPos = cur;
+    if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
+    if (itemPos >= input.length) break;
+    if (guardable && !startsFirstSet(combinator, input, itemPos)) break;
+    const end = child(input, itemPos, ctx);
+    if (end <= itemPos) break;
+    if (values !== void 0) values.push(ctx._sv);
+    cur = end;
+    remaining--;
+  }
+  ctx._sv = values;
+  return cur;
+}
 function many(combinator, opts = {}) {
   const { min, max } = resolveBounds("many()", opts);
   if (min >= 1) return atLeast(combinator, min, max);
@@ -3949,17 +4071,21 @@ function many(combinator, opts = {}) {
   const def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max } };
   let expected;
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => repeatScalarTail(combinator, scalarChild, input, pos, ctx, guardable, def.valueUnused ? void 0 : [], max);
   return {
     _tag: "many",
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       const values = def.valueUnused ? void 0 : [];
+      const rollbackNeeded = needsTriviaRollback(ctx);
       let cur = pos;
       let count = 0;
       while (cur < input.length) {
         if (count >= max) break;
-        const item = repItem(combinator, input, cur, ctx, guardable, false);
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
         if (item === "stop") break;
         if ("fail" in item) {
           if (!item.fail.ok && item.fail.committed) return item.fail;
@@ -3976,7 +4102,7 @@ function many(combinator, opts = {}) {
         }
         if (values !== void 0) values.push(item.value);
         count++;
-        cur = item.end;
+        cur = item.span.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
@@ -3994,30 +4120,47 @@ function atLeast(combinator, min, max) {
   const def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max } };
   let expected;
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = scalarChild(input, pos, ctx);
+    if (cur < 0) return cur;
+    const values = def.valueUnused ? void 0 : [ctx._sv];
+    for (let count = 1; count < min; count++) {
+      let itemPos = cur;
+      if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
+      const end = scalarChild(input, itemPos, ctx);
+      if (end < 0) return ~cur;
+      cur = end;
+      if (values !== void 0) values.push(ctx._sv);
+    }
+    return repeatScalarTail(combinator, scalarChild, input, cur, ctx, guardable, values, max - min);
+  };
   return {
     _tag: "oneOrMore",
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       if (!first.ok) return first;
       const values = def.valueUnused ? void 0 : [first.value];
+      const rollbackNeeded = needsTriviaRollback(ctx);
       let cur = first.span.end;
       let count = 1;
       while (count < min) {
-        const item = repItem(combinator, input, cur, ctx, guardable, true);
+        const item = repItem(combinator, input, cur, ctx, guardable, true, rollbackNeeded);
         if (item === "stop" || "fail" in item) {
           if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
           expected ??= deriveExpected(combinator);
           return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
         }
         if (values !== void 0) values.push(item.value);
-        cur = item.end;
+        cur = item.span.end;
         count++;
       }
       while (cur < input.length) {
         if (count >= max) break;
-        const item = repItem(combinator, input, cur, ctx, guardable, false);
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
         if (item === "stop") break;
         if ("fail" in item) {
           if (!item.fail.ok && item.fail.committed) return item.fail;
@@ -4034,7 +4177,7 @@ function atLeast(combinator, min, max) {
         }
         if (values !== void 0) values.push(item.value);
         count++;
-        cur = item.end;
+        cur = item.span.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
@@ -4047,10 +4190,22 @@ function optional(combinator) {
     isTrivia: false
   };
   const firstSetSkippable = !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => {
+    if (firstSetSkippable && !startsFirstSet(combinator, input, pos)) {
+      ctx._sv = null;
+      return pos;
+    }
+    const end = scalarChild(input, pos, ctx);
+    if (end >= 0) return end;
+    ctx._sv = null;
+    return pos;
+  };
   return {
     _tag: "optional",
     _meta: meta,
     _def: { tag: "optional", parser: combinator },
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) {
         return { ok: true, value: null, span: { start: pos, end: pos } };
@@ -4084,6 +4239,43 @@ function sepBy(combinator, separatorArg, opts = {}) {
     expected ??= deriveExpected(combinator);
     return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } };
   };
+  const scalarExpected = deriveExpected(combinator);
+  const scalarChild = scalarOf(combinator);
+  const scalarSeparator = scalarOf(separator);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = scalarChild(input, pos, ctx);
+    if (cur < 0) {
+      if (min >= 1) {
+        ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
+        return ~pos;
+      }
+      ctx._sv = [];
+      return pos;
+    }
+    const values = [ctx._sv];
+    while (values.length < max && (cur < input.length || values.length < min)) {
+      const beforeSeparator = cur;
+      let separatorPos = cur;
+      if (ctx.trivia) separatorPos = advanceTrivia(input, cur, ctx);
+      const separatorEnd = scalarSeparator(input, separatorPos, ctx);
+      if (separatorEnd < 0) break;
+      let itemPos = separatorEnd;
+      if (ctx.trivia) itemPos = advanceTrivia(input, itemPos, ctx);
+      const itemEnd = scalarChild(input, itemPos, ctx);
+      if (itemEnd < 0) {
+        cur = trailing === "allow" ? separatorEnd : beforeSeparator;
+        break;
+      }
+      values.push(ctx._sv);
+      cur = itemEnd;
+    }
+    if (values.length < min) {
+      ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
+      return ~cur;
+    }
+    ctx._sv = values;
+    return cur;
+  };
   return {
     _tag: "sepBy",
     _meta: meta,
@@ -4099,6 +4291,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
       // this option surface already; parity is held by test/parity, not by hope.
       ...keepSeparators ? { keepSeparators: true } : {}
     },
+    _parseScalar: keepSeparators ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       const values = [];
@@ -4608,9 +4801,9 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
       const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState, tags) : build(children, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children };
-      const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
+      const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
-        pushCstChild(ctx, built, rawEntry2);
+        pushCstChild(ctx, built, rawEntry);
       }
       return { ok: true, value: built, span };
     }
@@ -4618,11 +4811,54 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
 }
 
 // src/combinators/map.ts
+var JSON_STRING_BODY = String.raw`(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*`;
 function transform(combinator, fn) {
+  const observesSpan = fn.length > 1;
+  const sequenceDef = combinator._def.tag === "sequence" ? combinator._def : void 0;
+  const terms = sequenceDef?.parsers;
+  const inner = terms?.[1];
+  const fused = terms?.length === 3 && terms[0]._def.tag === "literal" && terms[0]._def.value === '"' && !terms[0]._def.caseInsensitive && inner._def.tag === "regex" && inner._def.source === JSON_STRING_BODY && inner._def.flags === "" && terms[2]._def.tag === "literal" && terms[2]._def.value === '"' && !terms[2]._def.caseInsensitive && inner._stickyRegex !== void 0;
+  const child = scalarOf(combinator);
+  const parseScalar = fused ? (() => {
+    const body = inner._stickyRegex;
+    const tuple = ['"', "", '"'];
+    const expected = [JSON.stringify('"')];
+    return (input, pos, ctx) => {
+      if (ctx.trivia !== void 0) {
+        const end2 = child(input, pos, ctx);
+        if (end2 < 0) return end2;
+        ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end: end2 }) : fn(ctx._sv);
+        return end2;
+      }
+      if (input.charCodeAt(pos) !== 34) {
+        ctx._fx = expected;
+        return ~pos;
+      }
+      body.lastIndex = pos + 1;
+      const match = body.exec(input);
+      const close = pos + 1 + match[0].length;
+      if (input.charCodeAt(close) !== 34) {
+        ctx._fx = expected;
+        return ~close;
+      }
+      tuple[1] = match[0];
+      const end = close + 1;
+      ctx._sv = observesSpan ? fn(tuple, { start: pos, end }) : fn(tuple);
+      return end;
+    };
+  })() : /* @__PURE__ */ (() => {
+    return (input, pos, ctx) => {
+      const end = child(input, pos, ctx);
+      if (end < 0) return end;
+      ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end }) : fn(ctx._sv);
+      return end;
+    };
+  })();
   return {
     _tag: "transform",
     _meta: combinator._meta,
     _def: { tag: "transform", parser: combinator, fn },
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       const result = combinator.parse(input, pos, ctx);
       if (!result.ok) return result;
@@ -4637,9 +4873,11 @@ function trivia(combinator) {
     _meta: {
       ...combinator._meta,
       isTrivia: true,
+      triviaScanner: fastTriviaScanner(combinator),
       ...kindLabels ? { triviaKindLabels: kindLabels } : {}
     },
     _def: { tag: "trivia", parser: combinator },
+    _parseScalar: scalarOf(combinator),
     parse: combinator.parse.bind(combinator)
   };
 }
@@ -5113,108 +5351,6 @@ function evalRuleMapIR(ir) {
   return Object.entries(map);
 }
 
-// src/table/ops.ts
-var OP_LIT = 1;
-var OP_RX = 2;
-var OP_SEQ = 3;
-var OP_SEQV = 4;
-var OP_CHOICE = 5;
-var OP_REP = 6;
-var OP_REPV = 7;
-var OP_OPT = 8;
-var OP_XFORM = 9;
-var OP_NODE = 10;
-var OP_RULE = 11;
-var OP_GATE = 12;
-var OP_NOT = 13;
-var OP_PEEK = 14;
-var OP_LEAF = 15;
-var OP_EMPTY = 16;
-var OP_LIT_TRACK = 17;
-var OP_RX_TRACK = 18;
-var OP_NODE_TRACK = 19;
-var OP_SCOPE = 20;
-var OP_EXPECT = 21;
-var OP_SEQX = 22;
-var OP_SCAN = 23;
-var OP_FIELD = 24;
-var OP_LIT_CI = 27;
-var OP_LIT_CI_TRACK = 28;
-var OP_TOKEN = 29;
-var OP_SCOPE_CAP = 30;
-var OP_WITHCTX = 31;
-var OP_GUARD = 32;
-var OP_ADJ = 33;
-var OP_GREEDY = 34;
-var OP_REJECT = 35;
-var OP_ARMGATE = 36;
-var OP_LIVE = 37;
-var OP_ATTEMPT = 38;
-var OP_LABEL = 39;
-var OP_COV = 40;
-var OP_SCOPE_PLAIN = 41;
-var OP_LEX_BODY = 42;
-var OP_LEX_PROGRAM = 43;
-var OP_DISPATCH = 25;
-var OP_ROUTED = 26;
-var OP_NAMES = {
-  [OP_LIT]: "LIT",
-  [OP_RX]: "RX",
-  [OP_SEQ]: "SEQ",
-  [OP_SEQV]: "SEQV",
-  [OP_CHOICE]: "CHOICE",
-  [OP_REP]: "REP",
-  [OP_REPV]: "REPV",
-  [OP_OPT]: "OPT",
-  [OP_XFORM]: "XFORM",
-  [OP_NODE]: "NODE",
-  [OP_RULE]: "RULE",
-  [OP_GATE]: "GATE",
-  [OP_NOT]: "NOT",
-  [OP_PEEK]: "PEEK",
-  [OP_LEAF]: "LEAF",
-  [OP_EMPTY]: "EMPTY",
-  [OP_LIT_TRACK]: "LIT_TRACK",
-  [OP_RX_TRACK]: "RX_TRACK",
-  [OP_NODE_TRACK]: "NODE_TRACK",
-  [OP_SCOPE]: "SCOPE",
-  [OP_EXPECT]: "EXPECT",
-  [OP_SEQX]: "SEQX",
-  [OP_SCAN]: "SCAN",
-  [OP_FIELD]: "FIELD",
-  [OP_LIT_CI]: "LIT_CI",
-  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
-  [OP_DISPATCH]: "DISPATCH",
-  [OP_ROUTED]: "ROUTED",
-  [OP_TOKEN]: "TOKEN",
-  [OP_SCOPE_CAP]: "SCOPE_CAP",
-  [OP_WITHCTX]: "WITHCTX",
-  [OP_GUARD]: "GUARD",
-  [OP_ADJ]: "ADJ",
-  [OP_GREEDY]: "GREEDY",
-  [OP_REJECT]: "REJECT",
-  [OP_ARMGATE]: "ARMGATE",
-  [OP_LIVE]: "LIVE",
-  [OP_ATTEMPT]: "ATTEMPT",
-  [OP_LABEL]: "LABEL",
-  [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
-  [OP_LEX_BODY]: "LEX_BODY",
-  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
-};
-
-// src/table/scan-shapes.ts
-var META2 = new Set("()[]{}*+?|^$.".split(""));
-
-// src/table/assemble.ts
-var EMIT_ENABLED = globalThis.process?.env?.PM_TABLE_EMIT !== "0";
-var EMPTY_TL2 = Object.freeze([]);
-var EMPTY_SENTS = Object.freeze([]);
-
-// src/analysis/duplication.ts
-var WORD_RE_SRC = "-?[A-Za-z][A-Za-z0-9_-]*";
-var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
-
 // src/compiler/linker.ts
 function normalizeCstCollapse(collapse) {
   if (collapse === true) return () => true;