parseman 0.52.0 → 0.54.0

package/dist/analysis/diagnostics.js

@@ -1155,65 +1155,17 @@ function plainRegexSource(p) {
   const d = p._def;
   return d.tag === "regex" && d.flags === "" ? d.source : null;
 }
-var visitSpec0;
-var visitSpec1;
-var visitSpec2;
-var visitSpec3;
-var visitValue0;
-var visitValue1;
-var visitValue2;
-var visitValue3;
 function commonLabeledTriviaVisitor(spec) {
-  if (spec === visitSpec0) return visitValue0;
-  if (spec === visitSpec1) return visitValue1;
-  if (spec === visitSpec2) return visitValue2;
-  if (spec === visitSpec3) return visitValue3;
-  const sources = spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : [];
-  const visitor = commonCssTriviaVisitor(sources);
-  visitSpec3 = visitSpec2;
-  visitValue3 = visitValue2;
-  visitSpec2 = visitSpec1;
-  visitValue2 = visitValue1;
-  visitSpec1 = visitSpec0;
-  visitValue1 = visitValue0;
-  visitSpec0 = spec;
-  visitValue0 = visitor;
-  return visitor;
-}
-var armSpec0;
-var armSpec1;
-var armSpec2;
-var armSpec3;
-var armValue0;
-var armValue1;
-var armValue2;
-var armValue3;
+  return commonCssTriviaVisitor(spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : []);
+}
 function charArmsFor(spec) {
-  if (spec === armSpec0) return armValue0;
-  if (spec === armSpec1) return armValue1;
-  if (spec === armSpec2) return armValue2;
-  if (spec === armSpec3) return armValue3;
-  let arms = [];
-  if (spec.minRepeats > 1) {
-    arms = null;
-  } else {
-    for (const arm of spec.arms) {
-      const c = classifyParser(arm.parser);
-      if (!c) {
-        arms = null;
-        break;
-      }
-      arms.push(c);
-    }
+  if (spec.minRepeats > 1) return null;
+  const arms = [];
+  for (const arm of spec.arms) {
+    const c = classifyParser(arm.parser);
+    if (!c) return null;
+    arms.push(c);
   }
-  armSpec3 = armSpec2;
-  armValue3 = armValue2;
-  armSpec2 = armSpec1;
-  armValue2 = armValue1;
-  armSpec1 = armSpec0;
-  armValue1 = armValue0;
-  armSpec0 = spec;
-  armValue0 = arms;
   return arms;
 }
 function charTriviaEnd(input, cur, arms) {
@@ -1329,12 +1281,16 @@ function analyzeLabeledTrivia(trivia2) {
     }
     arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
   }
-  const spec = {
+  return cacheLabeledTrivia(trivia2, labeledTriviaSpec(arms, minRepeats));
+}
+function labeledTriviaSpec(arms, minRepeats) {
+  return {
     labels: arms.map((a) => a.label),
     arms,
-    minRepeats
+    minRepeats,
+    visitor: commonLabeledTriviaVisitor({ arms, minRepeats }),
+    charArms: charArmsFor({ arms, minRepeats })
   };
-  return cacheLabeledTrivia(trivia2, spec);
 }
 function matchArmAt(input, pos, arm, state) {
   if (!startsFirstSet(arm, input, pos)) return null;
@@ -1364,7 +1320,7 @@ function scanLabeledTriviaChunks(input, cur, spec, state) {
   return { end: pos, chunks };
 }
 function scanLabeledTriviaEnd(input, cur, spec, state) {
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaEnd(input, cur, chars);
   let pos = cur;
   let count = 0;
@@ -1382,9 +1338,9 @@ function scanLabeledTriviaEnd(input, cur, spec, state) {
 }
 function visitLabeledTrivia(input, cur, spec, state, visit) {
   if (spec.minRepeats > 1) return void 0;
-  const common = commonLabeledTriviaVisitor(spec);
+  const common = spec.visitor;
   if (common !== null) return common(input, cur, visit);
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaVisit(input, cur, chars, visit);
   let pos = cur;
   let count = 0;
@@ -1451,7 +1407,7 @@ function resolveAdjacencyKindMask(trivia2, kinds) {
   return mask;
 }
 function triviaKindMaskAt(input, pos, spec, state) {
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaKindMask(input, pos, chars);
   let cur = pos;
   let mask = 0;
@@ -3252,6 +3208,53 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
+    case "lazy": {
+      try {
+        return hasDirectBuildDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "attempt":
+    case "not":
+    case "peek":
+    case "withCtx":
+    case "expect":
+    case "transform":
+      return hasDirectBuildDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
+    case "dispatch":
+      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
+    case "scanTo":
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
+    case "recover":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
+    case "routed":
+      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
+    default:
+      return false;
+  }
+}
 function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
   if (seen.has(p)) return false;
   seen.add(p);
@@ -4153,7 +4156,7 @@ function buildFieldMap(captures) {
   if (!captures?.length) return void 0;
   const out = {};
   for (const cap of captures) {
-    const entry = { value: cap.value, span: cap.span };
+    const entry = cap.leading === void 0 ? { value: cap.value, span: cap.span } : { value: cap.value, span: cap.span, leading: cap.leading, trailing: cap.trailing };
     const current = out[cap.name];
     if (current === void 0) out[cap.name] = entry;
     else if (Array.isArray(current)) current.push(entry);
@@ -4162,6 +4165,23 @@ function buildFieldMap(captures) {
   return out;
 }
 
+// src/combinators/field-trivia.ts
+var LEAD = { at: -1 };
+var FIELD_LEADING_TRIVIA = 1;
+var FIELD_TRAILING_TRIVIA = 2;
+function triviaFieldCapture(name, value, input, start, end, leadFrom, trailEnd) {
+  return {
+    name,
+    value,
+    span: { start, end },
+    leading: leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : "",
+    trailing: trailEnd > end ? input.slice(end, trailEnd) : ""
+  };
+}
+function leadsTrivia(p) {
+  return p._def.tag === "field" && p._def.leadingTrivia === true;
+}
+
 // src/combinators/dispatch.ts
 function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(parser2)) return false;
@@ -5130,6 +5150,7 @@ function unwrapSeparator(separator) {
 }
 function sepBy(combinator, separatorArg, opts = {}) {
   const { sep: separator, keep: keepSeparators } = unwrapSeparator(separatorArg);
+  const separatorLeads = leadsTrivia(separator);
   const { min, max } = resolveBounds("sepBy()", opts);
   const trailing = opts.trailing ?? "forbid";
   const meta = {
@@ -5194,7 +5215,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,
+    _parseScalar: keepSeparators || separatorLeads ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       const values = [];
@@ -5226,6 +5247,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
             sepPos = advanceTrivia(input, cur, ctx);
           }
         }
+        if (separatorLeads) LEAD.at = cur;
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) {
           rollbackTrivia(ctx, loopMark);
@@ -5377,16 +5399,41 @@ function label(name, combinator) {
     }
   };
 }
-function field(name, combinator) {
+function field(name, combinator, opts) {
+  const leadingTrivia = opts?.leadingTrivia === true;
+  const trailingTrivia = opts?.trailingTrivia === true;
+  if (!leadingTrivia && !trailingTrivia) {
+    return {
+      _tag: combinator._tag,
+      _meta: combinator._meta,
+      _def: { tag: "field", name, parser: combinator },
+      parse(input, pos, ctx) {
+        const result = combinator.parse(input, pos, ctx);
+        if (!result.ok) return result;
+        ctx._fields?.push({ name, value: result.value, span: result.span });
+        return result;
+      }
+    };
+  }
   return {
     _tag: combinator._tag,
     _meta: combinator._meta,
-    _def: { tag: "field", name, parser: combinator },
+    _def: {
+      tag: "field",
+      name,
+      parser: combinator,
+      ...leadingTrivia ? { leadingTrivia: true } : {},
+      ...trailingTrivia ? { trailingTrivia: true } : {}
+    },
     parse(input, pos, ctx) {
+      const leadFrom = LEAD.at;
+      LEAD.at = -1;
       const result = combinator.parse(input, pos, ctx);
       if (!result.ok) return result;
-      ctx._fields?.push({ name, value: result.value, span: result.span });
-      return result;
+      const end = result.span.end;
+      const trailEnd = trailingTrivia && ctx.trivia ? consumeTrivia(input, end, ctx) : end;
+      ctx._fields?.push(triviaFieldCapture(name, result.value, input, result.span.start, end, leadingTrivia ? leadFrom : -1, trailEnd));
+      return trailEnd === end ? result : { ok: true, value: result.value, span: { start: result.span.start, end: trailEnd } };
     }
   };
 }
@@ -6531,6 +6578,16 @@ var Encoder = class {
     this.kIndex.set(key, i);
     return i;
   }
+  fieldSpecIndex = /* @__PURE__ */ new Map();
+  fieldSpecSlot(name, bits) {
+    const key = JSON.stringify([name, bits]);
+    const hit = this.fieldSpecIndex.get(key);
+    if (hit !== void 0) return hit;
+    const i = this.k.length;
+    this.k.push([name, bits]);
+    this.fieldSpecIndex.set(key, i);
+    return i;
+  }
   /**
    * A `notAdjacent({ kinds })` filter, pooled by its CONTENTS.
    *
@@ -7151,8 +7208,10 @@ var Encoder = class {
         for (let i = 0; i < arms.length; i++) this.code[head + 6 + i] = arms[i];
         return head;
       }
-      case "field":
-        return this.emit(OP_FIELD, this.constant(d.name), this.node(d.parser).ip);
+      case "field": {
+        const bits = (d.leadingTrivia === true ? FIELD_LEADING_TRIVIA : 0) | (d.trailingTrivia === true ? FIELD_TRAILING_TRIVIA : 0);
+        return this.emit(OP_FIELD, bits === 0 ? this.constant(d.name) : this.fieldSpecSlot(d.name, bits), this.node(d.parser).ip);
+      }
       case "lazy": {
         const refName = p._ruleName;
         const winner = refName === void 0 ? void 0 : this.winners?.[refName];
@@ -8825,6 +8884,26 @@ function leadingLiteralFamily(code, constants, ip, minDepth = 2, limit = 4) {
   };
   return walk(ip, 0);
 }
+function largeChoiceLiteralPretest(code, constants, armIp) {
+  const child = leadingScalarTerminal(code, armIp, 2, true, true);
+  if (child >= 0) {
+    const spec = constants[code[child + 1]];
+    if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) return [child];
+  }
+  const family = leadingLiteralFamily(code, constants, armIp);
+  return family !== void 0 && family.length >= 2 && family.every((terminal) => {
+    const value = constants[code[terminal + 1]];
+    return typeof value === "string" && value.length >= 2;
+  }) ? family : void 0;
+}
+
+// src/table/field-spec.ts
+function fieldSpec(slot) {
+  return Array.isArray(slot) ? { name: slot[0], bits: slot[1] } : { name: slot, bits: 0 };
+}
+function leadingTriviaFieldAt(code, k, ip) {
+  return code[ip] === OP_FIELD && (fieldSpec(k[code[ip + 1]]).bits & FIELD_LEADING_TRIVIA) !== 0;
+}
 
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
@@ -8899,7 +8978,11 @@ var EMITTED_PARAMS = [
   // Appended for old precompiled-factory ABI: old factories ignore it.
   "adjacencyHolds",
   // Appended for selected composite lexical programs; old factories ignore it.
-  "LEXPROG"
+  "LEXPROG",
+  // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
+  // old factories ignore them.
+  "LEAD",
+  "triviaFieldCapture"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -9159,20 +9242,12 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
           if (child >= 0) scalarSpecs.add(code[child + 1]);
           continue;
         }
-        if (child >= 0) {
-          const spec = k[code[child + 1]];
-          if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
-            largeChoiceScalarSpecs.add(code[child + 1]);
-            continue;
-          }
-        }
-        const family = leadingLiteralFamily(code, k, armIp);
-        if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
-          const value = k[code[terminal + 1]];
-          return typeof value === "string" && value.length >= 2;
-        })) {
-          largeChoiceLiteralFamilies.set(armIp, family);
+        const literals = largeChoiceLiteralPretest(code, k, armIp);
+        if (literals !== void 0 && literals.length === 1 && literals[0] === child) {
+          largeChoiceScalarSpecs.add(code[child + 1]);
+          continue;
         }
+        if (literals !== void 0) largeChoiceLiteralFamilies.set(armIp, literals);
         const sequence6 = leadingScalarSequence(code, armIp);
         if (sequence6 !== void 0 && (sequence6.trivia < 0 || swapLegal && t2.triviaScan[sequence6.trivia] != null)) {
           largeChoiceScalarSequences.set(armIp, sequence6);
@@ -9596,14 +9671,31 @@ return v
 }`;
       }
       case OP_FIELD: {
-        const name = q(k[code[ip + 1]]);
+        const spec = fieldSpec(k[code[ip + 1]]);
+        const name = q(spec.name);
         const child = link(code[ip + 2]);
-        return `${head}
+        if (spec.bits === 0) {
+          return `${head}
 const v=${child}(input,pos,ctx)
 if(v===FAIL)return FAIL
 const f=ctx._fields
 if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
 return v
+}`;
+        }
+        const leading = (spec.bits & FIELD_LEADING_TRIVIA) !== 0;
+        const trailing = (spec.bits & FIELD_TRAILING_TRIVIA) !== 0;
+        return `${head}
+const lf=${leading ? "LEAD.at" : "-1"}
+LEAD.at=-1
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+const e=EC.e
+const te=${trailing ? "ctx.trivia!==undefined?consumeTrivia(input,e,ctx):e" : "e"}
+const f=ctx._fields
+if(f!==undefined)f.push(triviaFieldCapture(${name},v,input,pos,e,lf,te))
+EC.e=te
+return v
 }`;
       }
       case OP_EXPECT: {
@@ -9899,7 +9991,10 @@ return v
               `if(!adjacencyHolds(input,cur,ctx,${negated ? "true" : "false"},${kinds})){ctx._fe=cur;ctx._fx=${expected};return FAIL}`,
               `${vn}=null`
             );
-          } else parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L)));
+          } else {
+            const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
+            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)));
+          }
           names.push(vn);
         }
         parts.push("EC.e=cur");
@@ -10299,7 +10394,7 @@ let sp=cur
 ${hasTrivia === "false" ? "" : hasTrivia === "true" ? `sp=${skip}(input,sp,ctx)
 ` : `if(hasTrivia)sp=${skip}(input,sp,ctx)
 `}ctx._fc=false
-const sv=${sep}(input,sp,ctx)
+${sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp) ? "LEAD.at=cur\n" : ""}const sv=${sep}(input,sp,ctx)
 if(sv===FAIL){
 ${rb}
 if(ctx._fc===true)return FAIL
@@ -10681,6 +10776,10 @@ function sequence(...parsers) {
     (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
   }
   const hasAdjacency = adjacency !== null;
+  let leading = null;
+  for (let i = 1; i < parsers.length; i++) {
+    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
+  }
   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
@@ -10728,7 +10827,7 @@ function sequence(...parsers) {
     _tag: "sequence",
     _meta: meta,
     _def: def,
-    _parseScalar: hasAdjacency ? void 0 : parseScalar,
+    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const tolerant = ctx._tolerant === true;
       if (tolerant) {
@@ -10762,6 +10861,7 @@ function sequence(...parsers) {
           const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
           const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
           const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (leading?.[i] === true) LEAD.at = cur;
           const result = parsers[i].parse(input, termPos, ctx);
           if (!result.ok) return result;
           if (values !== void 0) values.push(result.value);
@@ -10803,6 +10903,7 @@ function withRuleTrivia(trivia2, ctx, run) {
     ctx.triviaKindLabels = savedLabels;
   }
 }
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
 function ref() {
   let resolved = null;
   let resolvedScalar = null;
@@ -10818,7 +10919,7 @@ function ref() {
     _def: {
       tag: "lazy",
       thunk: () => {
-        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        if (!resolved) throw UNDEFINED_REF;
         return resolved;
       }
     },
@@ -11793,6 +11894,12 @@ function assemble(t2, prog, cfg) {
     rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
+  function leadingFieldTerm(step, child, input, cur, ctx) {
+    return step((i, p, c) => {
+      LEAD.at = cur;
+      return child(i, p, c);
+    }, input, cur, ctx);
+  }
   function committed3(c) {
     return c._fc === true;
   }
@@ -12430,12 +12537,27 @@ function assemble(t2, prog, cfg) {
         };
       }
       case OP_FIELD: {
-        const name = k[code[ip + 1]];
+        const { name, bits } = fieldSpec(k[code[ip + 1]]);
         const child = link(code[ip + 2]);
+        if (bits === 0) {
+          return (input, pos, ctx) => {
+            const v = child(input, pos, ctx);
+            if (v === FAIL) return FAIL;
+            ctx._fields?.push({ name, value: v, span: { start: pos, end: EC.e } });
+            return v;
+          };
+        }
+        const leading = (bits & FIELD_LEADING_TRIVIA) !== 0;
+        const trailing = (bits & FIELD_TRAILING_TRIVIA) !== 0;
         return (input, pos, ctx) => {
+          const leadFrom = leading ? LEAD.at : -1;
+          LEAD.at = -1;
           const v = child(input, pos, ctx);
           if (v === FAIL) return FAIL;
-          ctx._fields?.push({ name, value: v, span: { start: pos, end: EC.e } });
+          const end = EC.e;
+          const trailEnd = trailing && ctx.trivia !== void 0 ? consumeTrivia(input, end, ctx) : end;
+          ctx._fields?.push(triviaFieldCapture(name, v, input, pos, end, leadFrom, trailEnd));
+          EC.e = trailEnd;
           return v;
         };
       }
@@ -12869,6 +12991,12 @@ function assemble(t2, prog, cfg) {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
+              if (leadingTriviaFieldAt(code, k, kidIp)) {
+                return (input, cur, ctx, inherited) => {
+                  ctx._sync = sync ?? inherited;
+                  return leadingFieldTerm(step, kid, input, cur, ctx);
+                };
+              }
               return (input, cur, ctx, inherited) => {
                 ctx._sync = sync ?? inherited;
                 return step(kid, input, cur, ctx);
@@ -12946,9 +13074,12 @@ function assemble(t2, prog, cfg) {
           };
         }
         let hasAdj = false;
-        for (let i = 1; i < n; i++) if (code[code[base + i]] === OP_ADJ) {
-          hasAdj = true;
-          break;
+        for (let i = 1; i < n; i++) {
+          const kidIp = code[base + i];
+          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp)) {
+            hasAdj = true;
+            break;
+          }
         }
         if (hasAdj) {
           const first2 = link(code[base]);
@@ -12956,6 +13087,9 @@ function assemble(t2, prog, cfg) {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
+              if (leadingTriviaFieldAt(code, k, kidIp)) {
+                return (input, cur, ctx) => leadingFieldTerm(step, kid, input, cur, ctx);
+              }
               return (input, cur, ctx) => step(kid, input, cur, ctx);
             }
             const negated = code[kidIp + 1] === 1;
@@ -13318,7 +13452,7 @@ function assemble(t2, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
-          const predecide = !hostCst && !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
           const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
           const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
           const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
@@ -13541,6 +13675,75 @@ function assemble(t2, prog, cfg) {
             );
           };
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
+          const pBit = [];
+          const pRec = [];
+          if (!REC && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+            for (let i = 0; i < n; i++) {
+              for (const terminal of largeChoiceLiteralPretest(code, k, code[base + i]) ?? []) {
+                pBit.push(1 << i);
+                pRec.push(scalarFor(terminal));
+              }
+            }
+          }
+          const pn = pBit.length;
+          if (pn !== 0) {
+            return (input, pos, ctx) => {
+              const c = lead(input, pos);
+              const need = markCst(ctx);
+              const mRaw = MRAW;
+              const mTl = MTL;
+              const mLv = MLV;
+              const mFl = need ? ctx._fields?.length ?? 0 : 0;
+              const mEr = need ? ctx._errors?.length ?? 0 : 0;
+              const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+              const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+              if (c < 128) {
+                const bits = mask[c < 0 ? 128 : c];
+                let tested = 0;
+                let hit = 0;
+                for (let i = 0; i < pn; i++) {
+                  const b = pBit[i];
+                  if ((bits & b) === 0 || (hit & b) !== 0) continue;
+                  tested |= b;
+                  if (pRec[i](input, pos) >= 0) hit |= b;
+                }
+                return masked(
+                  input,
+                  pos,
+                  ctx,
+                  bits & (~tested | hit),
+                  need,
+                  mRaw,
+                  mTl,
+                  mLv,
+                  mFl,
+                  mEr,
+                  mLog,
+                  mRoot,
+                  void 0,
+                  0,
+                  pos
+                );
+              }
+              return general(
+                input,
+                pos,
+                ctx,
+                c,
+                need,
+                mRaw,
+                mTl,
+                mLv,
+                mFl,
+                mEr,
+                mLog,
+                mRoot,
+                void 0,
+                0,
+                pos
+              );
+            };
+          }
           return (input, pos, ctx) => {
             const c = lead(input, pos);
             const need = markCst(ctx);
@@ -13702,6 +13905,7 @@ function assemble(t2, prog, cfg) {
         const max = code[ip + 3];
         const sepIp = code[ip + 4];
         const sep = sepIp >= 0 ? link(sepIp) : void 0;
+        const sepLeads = sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp);
         const flags = code[ip + 5];
         const keepSeparators = (flags & 2) !== 0;
         const trailingAllowed = (flags & 1) !== 0;
@@ -13741,6 +13945,7 @@ function assemble(t2, prog, cfg) {
                 let sp = cur;
                 if (hasTrivia) sp = skipTrivia(input, sp, ctx);
                 ctx._fc = false;
+                if (sepLeads) LEAD.at = cur;
                 const sv = sep(input, sp, ctx);
                 if (sv === FAIL) {
                   if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -13830,6 +14035,7 @@ function assemble(t2, prog, cfg) {
               let sp = cur;
               if (hasTrivia) sp = skipTrivia(input, sp, ctx);
               ctx._fc = false;
+              if (sepLeads) LEAD.at = cur;
               const sv = sep(input, sp, ctx);
               if (sv === FAIL) {
                 if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -14152,20 +14358,9 @@ function assemble(t2, prog, cfg) {
               if (child >= 0) scalarFor(child);
               continue;
             }
-            if (child >= 0) {
-              const spec = k[code[child + 1]];
-              if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
-                scalarFor(child);
-                continue;
-              }
-            }
-            const family = leadingLiteralFamily(code, k, armIp);
-            if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
-              const value = k[code[terminal + 1]];
-              return typeof value === "string" && value.length >= 2;
-            })) {
-              for (const terminal of family) scalarFor(terminal);
-            }
+            const literals = largeChoiceLiteralPretest(code, k, armIp);
+            if (literals !== void 0) for (const terminal of literals) scalarFor(terminal);
+            if (literals !== void 0 && literals.length === 1 && literals[0] === child) continue;
             const sequence6 = leadingScalarSequence(code, armIp);
             if (sequence6 !== void 0 && (sequence6.trivia < 0 || triviaScan[sequence6.trivia] != null)) {
               for (const terminal of sequence6.terminals) scalarFor(terminal);
@@ -14231,7 +14426,9 @@ function assemble(t2, prog, cfg) {
         scanTriviaCompact,
         t2.lex,
         adjacencyHolds,
-        t2.lexPrograms
+        t2.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = new Set(pre.reached);
     }
@@ -14313,7 +14510,9 @@ function assemble(t2, prog, cfg) {
         scanTriviaCompact,
         t2.lex,
         adjacencyHolds,
-        t2.lexPrograms
+        t2.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = em.reached;
     } catch (e) {
@@ -14489,7 +14688,9 @@ var AssemblyCache = class {
     return made;
   }
 };
-function tableRules(source, artifactMetadata = {}) {
+function tableRules(source, metadataOrEntry = {}) {
+  const entry = typeof metadataOrEntry === "string" ? metadataOrEntry : void 0;
+  const artifactMetadata = typeof metadataOrEntry === "string" ? {} : metadataOrEntry;
   const prog = expandCompact(source);
   const resolved = resolveTable(prog);
   const cache = new AssemblyCache(prog, resolved);
@@ -14497,7 +14698,7 @@ function tableRules(source, artifactMetadata = {}) {
   const skipOf = prog.scanSkipOf;
   let last;
   let selected;
-  return stampRuleMap(prog, {
+  const map = stampRuleMap(prog, {
     runRule: (ri, input, pos, ctx) => {
       const a = selected ?? cache.forCtx(ctx);
       selected = void 0;
@@ -14518,6 +14719,9 @@ function tableRules(source, artifactMetadata = {}) {
       return a.scanSkip[skipOf?.[ri] ?? -1];
     }
   }, artifactMetadata, resolved);
+  if (entry === void 0) return map;
+  if (!Object.hasOwn(map, entry)) throw new Error(`tableRules: the program has no rule ${JSON.stringify(entry)}`);
+  return map[entry];
 }
 
 // src/table/emit.ts
@@ -14672,11 +14876,15 @@ function emitTableExpression(prog, opts = {}) {
   const entry = opts.entry === void 0 ? "grammar" : opts.entry;
   const ref2 = opts.runtimeRef ?? "tableRules";
   const fns = opts.fnSources ?? prog.fns.map(() => "() => {}");
-  const close = `}${opts.metadataSource === void 0 ? "" : `,${opts.metadataSource}`})`;
+  const meta = opts.metadataSource;
+  if (entry !== null && meta !== void 0) {
+    throw new Error("emitTableExpression: metadataSource is for the rule-map form (entry: null); a single entry carries none");
+  }
+  const tail = entry !== null ? `,${jsString(entry)}` : meta === void 0 ? "" : `,${meta}`;
   return [
     `/* @__PURE__ */ ${ref2}({`,
     ...programFields(prog, fns, opts),
-    entry === null ? close : `${close}[${jsString(entry)}]`
+    `}${tail})`
   ].join("\n");
 }
 
@@ -14745,7 +14953,8 @@ function children(def, winners) {
         return [];
       }
       const name = resolved._ruleName;
-      return name && winners?.[name] ? [winners[name]] : [resolved];
+      const winner = name ? winners?.[name] : void 0;
+      return winner !== void 0 && winner._def !== def ? [winner] : [resolved];
     }
     default:
       return [];
@@ -14770,16 +14979,39 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
+  const selfWinnerBody = (parser2) => {
+    if (parser2._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser2);
+    if (name === void 0 || winners[name] !== parser2) return void 0;
+    try {
+      return parser2._def.thunk();
+    } catch {
+      return void 0;
+    }
+  };
+  const slotsPerBody = /* @__PURE__ */ new Map();
+  if (winners) {
+    for (const winner of Object.values(winners)) {
+      const body = selfWinnerBody(winner);
+      if (body !== void 0) slotsPerBody.set(body, (slotsPerBody.get(body) ?? 0) + 1);
+    }
+  }
+  const sharedBody = (parser2) => (slotsPerBody.get(parser2) ?? 0) > 1;
+  const ownRule = (parser2, rule2) => {
+    const id = `rule:${rule2}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules.set(parser2, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2, path) => {
     if (seen.has(parser2)) return;
     seen.add(parser2);
     const rule2 = winnerNames.get(parser2) ?? parser2._ruleName;
-    if (rule2 && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
-      const id = `rule:${rule2}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules.set(parser2, id);
+    const body = selfWinnerBody(parser2);
+    if (rule2 && body === void 0 && !sharedBody(parser2) && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
+      ownRule(parser2, rule2);
     }
+    if (rule2 && body !== void 0 && sharedBody(body)) ownRule(parser2, rule2);
     if (parser2._def.tag === "choice") {
       const ids = parser2._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
       choices.set(parser2, ids);
@@ -14800,7 +15032,13 @@ function buildGrammarPlan(entry, winners) {
   };
   const roots = Array.isArray(entry) ? entry : [entry];
   for (const root of roots) {
-    visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
+    const name = winnerNames.get(root) ?? root._ruleName ?? "entry";
+    const body = selfWinnerBody(root);
+    if (body !== void 0 && sharedBody(body) && !seen.has(root)) {
+      seen.add(root);
+      ownRule(root, name);
+    }
+    visit(body ?? root, name);
   }
   return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules };
 }
@@ -14824,7 +15062,7 @@ function payloadKey(p, d) {
     case "label":
       return `label\0${d.label}`;
     case "field":
-      return `field\0${d.name}`;
+      return `field\0${d.name}\0${d.leadingTrivia === true}\0${d.trailingTrivia === true}`;
     case "node":
       return `node\0${d.type ?? ""}\0${d.unwrap === true}\0${d.collapse === true}\0${fnKey(d.buildSrc, d.build)}`;
     case "transform":
@@ -16102,6 +16340,238 @@ ${lines.join("\n")}`);
 function runDuplicationDiagnostic(combinator, opt) {
   return reportDuplication(opt, (o) => analyzeDuplication(combinator, o));
 }
+function runDuplicationDiagnosticRules(ruleMap, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
+}
+
+// src/cst/reflection-symbols.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+
+// src/cst/reflection.ts
+function childrenOf2(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return [def.parser];
+    case "recover":
+      return [def.parser, def.sentinel];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "scanTo":
+      return [
+        def.sentinel,
+        ...def.skip,
+        ...def.recoverAt === void 0 ? [] : [def.recoverAt],
+        ...def.stopAt === void 0 ? [] : [def.stopAt]
+      ];
+    case "routed":
+      return def.fallback ? [def.fallback] : [];
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "adjacency":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf2(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [, rule2] of ruleMap) {
+    if (!followLazy && rule2._def.tag === "lazy") {
+      try {
+        const resolved = rule2._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule2, byType, seen, followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+
+// src/table/compile-rule-map.ts
+function resolveHostMode(ruleMap, explicit) {
+  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
+}
+function resolveTrackLines(ruleMap, explicit) {
+  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
+}
+function withAmbient(ruleMap, opts) {
+  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
+  const wrappers = /* @__PURE__ */ new Map();
+  return ruleMap.map(([name, rule2]) => {
+    if (rule2._meta.isTrivia) return [name, rule2];
+    const addTrivia = opts.trivia !== void 0 && rule2._meta.grammarTrivia === void 0;
+    const addScanSkip = opts.scanSkip !== void 0 && rule2._meta.grammarScanSkip === void 0;
+    if (!addTrivia && !addScanSkip) return [name, rule2];
+    let wrapped = wrappers.get(rule2);
+    if (wrapped === void 0) {
+      wrapped = {
+        ...rule2,
+        _meta: {
+          ...rule2._meta,
+          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
+          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
+        }
+      };
+      wrappers.set(rule2, wrapped);
+    }
+    return [name, wrapped];
+  });
+}
+function compileRuleMapRunnable(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  const reflection = collectGrammarReflection(ruleMap);
+  return {
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule2]) => hasDirectBuildDef(rule2)),
+    reflection,
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
+    prog: artifact
+  };
+}
+function encodeForRun(ruleMap, opts) {
+  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
+  const encodeMap = withAmbient(ruleMap, opts);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule2]) => rule2),
+    Object.fromEntries(encodeMap.filter(([, rule2]) => rule2._def.tag !== "lazy"))
+  ) : void 0;
+  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
+  const settings = {
+    hostMode,
+    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
+    ...opts.recovery === true ? { recovery: true } : {},
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  try {
+    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
+    return { prog, fnSrcs, hostMode, plan };
+  } catch (e) {
+    opts.refusals?.push(e instanceof Error ? e.message : String(e));
+    return null;
+  }
+}
+
+// src/compiler/borrowed-rules.ts
+var nameOf = (c) => c._ruleName;
+function deref(c) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = c;
+  while (current._def.tag === "lazy" && !seen.has(current)) {
+    seen.add(current);
+    try {
+      current = current._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return current;
+}
+function borrowedRuleReference(map) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rule2, self] of Object.entries(map)) {
+    let found;
+    const visit = (c) => {
+      if (found !== void 0) return;
+      if (c._def.tag === "lazy") {
+        if (!winnerWrapsReference(self, c)) {
+          const name = nameOf(c);
+          const winner = name !== void 0 && Object.hasOwn(map, name) ? map[name] : void 0;
+          if (winner !== void 0) {
+            if (winnerWrapsReference(winner, c) || deref(c) === deref(winner)) return;
+            found = name;
+            return;
+          }
+        }
+        if (seen.has(c)) return;
+        seen.add(c);
+        let body;
+        try {
+          body = c._def.thunk();
+        } catch {
+          return;
+        }
+        visit(body);
+        return;
+      }
+      if (seen.has(c)) return;
+      seen.add(c);
+      for (const child of childrenOf(c._def)) visit(child);
+    };
+    visit(self);
+    if (found !== void 0) return { rule: rule2, reference: found };
+  }
+  return void 0;
+}
+function borrowedRuleMessage(api, hit) {
+  return `${api}: rule "${hit.rule}" is a rule object borrowed from another grammar, and its graph references "${hit.reference}", which this grammar also defines. The interpreter would keep the other grammar's "${hit.reference}" while a compiled table binds this grammar's, so the two would accept different input. Compose the grammar that defines "${hit.rule}" instead of borrowing its rule object, so its references resolve to this grammar's rules.`;
+}
 
 // src/table/compile.ts
 var ENTRY = "Entry";
@@ -16112,7 +16582,47 @@ function ownSource(fn) {
   const name = fn.name;
   return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
 }
-function compile(combinator, mapFnSources, opts = {}) {
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
   runDuplicationDiagnostic(combinator, opts.duplication);
   const drain = beginCompileDegradationDrain();
   let compiled = false;
@@ -16626,7 +17136,7 @@ function rebuildCombinator(root, replacements) {
         out = label(d.label, one(d.parser));
         break;
       case "field":
-        out = field(d.name, one(d.parser));
+        out = field(d.name, one(d.parser), { leadingTrivia: d.leadingTrivia === true, trailingTrivia: d.trailingTrivia === true });
         break;
       case "token":
         out = token(one(d.parser));