parseman 0.52.0 → 0.54.0

package/dist/table/index.js

@@ -1485,65 +1485,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) {
@@ -1659,12 +1611,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;
@@ -1694,7 +1650,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;
@@ -1712,9 +1668,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;
@@ -1781,7 +1737,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;
@@ -2494,6 +2450,23 @@ function scalarOf(combinator) {
   return combinator._parseScalar;
 }
 
+// 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/sequence.ts
 function sequence(...parsers) {
   let adjacency = null;
@@ -2509,6 +2482,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
@@ -2556,7 +2533,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) {
@@ -2590,6 +2567,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);
@@ -3392,6 +3370,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;
@@ -3407,7 +3386,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;
       }
     },
@@ -4069,7 +4048,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);
@@ -6395,6 +6374,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 {
@@ -6469,7 +6468,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
@@ -6729,20 +6732,12 @@ function emitAssemblySource(t, 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 && t.triviaScan[sequence6.trivia] != null)) {
           largeChoiceScalarSequences.set(armIp, sequence6);
@@ -7166,14 +7161,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: {
@@ -7469,7 +7481,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");
@@ -7869,7 +7884,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
@@ -8742,6 +8757,12 @@ function assemble(t, 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;
   }
@@ -9379,12 +9400,27 @@ function assemble(t, 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;
         };
       }
@@ -9818,6 +9854,12 @@ function assemble(t, 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);
@@ -9895,9 +9937,12 @@ function assemble(t, 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]);
@@ -9905,6 +9950,9 @@ function assemble(t, 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;
@@ -10267,7 +10315,7 @@ function assemble(t, 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;
@@ -10490,6 +10538,75 @@ function assemble(t, 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);
@@ -10651,6 +10768,7 @@ function assemble(t, 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;
@@ -10690,6 +10808,7 @@ function assemble(t, 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);
@@ -10779,6 +10898,7 @@ function assemble(t, 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);
@@ -11101,20 +11221,9 @@ function assemble(t, 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);
@@ -11180,7 +11289,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = new Set(pre.reached);
     }
@@ -11262,7 +11373,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = em.reached;
     } catch (e) {
@@ -11438,7 +11551,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);
@@ -11446,7 +11561,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;
@@ -11467,6 +11582,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/analysis/gating.ts
@@ -12643,6 +12761,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.
    *
@@ -13263,8 +13391,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];
@@ -13702,11 +13832,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");
 }
 function emitFoldedModule(folded, opts = {}) {
@@ -13801,7 +13935,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 [];
@@ -13826,16 +13961,39 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
+  const selfWinnerBody = (parser) => {
+    if (parser._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser);
+    if (name === void 0 || winners[name] !== parser) return void 0;
+    try {
+      return parser._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 = (parser) => (slotsPerBody.get(parser) ?? 0) > 1;
+  const ownRule = (parser, rule) => {
+    const id = `rule:${rule}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules.set(parser, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser, path) => {
     if (seen.has(parser)) return;
     seen.add(parser);
     const rule = winnerNames.get(parser) ?? parser._ruleName;
-    if (rule && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
-      const id = `rule:${rule}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules.set(parser, id);
+    const body = selfWinnerBody(parser);
+    if (rule && body === void 0 && !sharedBody(parser) && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
+      ownRule(parser, rule);
     }
+    if (rule && body !== void 0 && sharedBody(body)) ownRule(parser, rule);
     if (parser._def.tag === "choice") {
       const ids = parser._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
       choices.set(parser, ids);
@@ -13856,7 +14014,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 };
 }
@@ -13880,7 +14044,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":
@@ -15162,84 +15326,8 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
-// src/table/compile.ts
-var ENTRY = "Entry";
-function ownSource(fn) {
-  if (typeof fn !== "function") return null;
-  const text = Function.prototype.toString.call(fn);
-  if (!text.includes("[native code]")) return text;
-  const name = fn.name;
-  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
-}
-function compile(combinator, mapFnSources, opts = {}) {
-  runDuplicationDiagnostic(combinator, opts.duplication);
-  const drain = beginCompileDegradationDrain();
-  let compiled = false;
-  try {
-    const out = compileImpl(combinator, mapFnSources, opts);
-    compiled = true;
-    return out;
-  } finally {
-    drain(compiled);
-  }
-}
-function compileImpl(combinator, mapFnSources, opts = {}) {
-  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
-  const settings = {
-    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
-    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
-  const artifact = closureArtifact(prog);
-  const entry = tableRules(prog)[ENTRY];
-  const offered = opts.fnSources ?? mapFnSources;
-  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
-  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
-  const runtimeOnly = [
-    ...prog.runtimeOnly ?? [],
-    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
-  ];
-  const printable = runtimeOnly.length === 0;
-  const emitOpts = { fnSources: sources };
-  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
-  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
-  return {
-    source,
-    inlineExpression,
-    ...printable ? {} : { runtimeOnly },
-    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
-    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
-    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
-    // so this is the channel.
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    parse(input, pos = 0) {
-      return runOnce(input, pos, createParseContext());
-    },
-    parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
-    },
-    /**
-     * NO LONGER REFUSES. It used to throw unless the caller passed
-     * `{ recovery: true }`, because setting `_tolerant` on a table with no
-     * recovery rows would report a clean parse with an empty error list whatever
-     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
-     * was the wrong question. `compile()` requires no such flag, so the refusal
-     * was a `CompiledParser` contract break; recovery is now always lowered and
-     * there is nothing left to refuse.
-     */
-    parseWithErrors(input, pos = 0) {
-      const ctx = createParseContext();
-      const errors = [];
-      ctx._errors = errors;
-      ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
-      return { ...r, errors };
-    }
-  };
-}
+// src/cst/reflection-symbols.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
 
 // src/cst/reflection.ts
 function childrenOf2(def) {
@@ -15326,6 +15414,7 @@ function collectFromCombinator(parser, out, seen, followLazy = true) {
 function collectGrammarReflection(ruleMap, opts) {
   const byType = /* @__PURE__ */ new Map();
   const followLazy = opts?.followLazy !== false;
+  const seen = /* @__PURE__ */ new Set();
   for (const [, rule] of ruleMap) {
     if (!followLazy && rule._def.tag === "lazy") {
       try {
@@ -15335,7 +15424,7 @@ function collectGrammarReflection(ruleMap, opts) {
       }
       continue;
     }
-    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+    collectFromCombinator(rule, byType, seen, followLazy);
   }
   return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
 }
@@ -15371,6 +15460,24 @@ function withAmbient(ruleMap, opts) {
     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(([, rule]) => hasDirectBuildDef(rule)),
+    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);
@@ -15439,11 +15546,185 @@ function compileRuleMap(ruleMap, opts = {}) {
     hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
+    rules: tableRules(artifact),
     prog: artifact
   };
 }
 
+// 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 [rule, 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, 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";
+function ownSource(fn) {
+  if (typeof fn !== "function") return null;
+  const text = Function.prototype.toString.call(fn);
+  if (!text.includes("[native code]")) return text;
+  const name = fn.name;
+  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+}
+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;
+  try {
+    const out = compileImpl(combinator, mapFnSources, opts);
+    compiled = true;
+    return out;
+  } finally {
+    drain(compiled);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts = {}) {
+  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
+  const settings = {
+    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
+    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+  const artifact = closureArtifact(prog);
+  const entry = tableRules(prog)[ENTRY];
+  const offered = opts.fnSources ?? mapFnSources;
+  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
+  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
+  const runtimeOnly = [
+    ...prog.runtimeOnly ?? [],
+    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
+  ];
+  const printable = runtimeOnly.length === 0;
+  const emitOpts = { fnSources: sources };
+  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
+  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
+  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  return {
+    source,
+    inlineExpression,
+    ...printable ? {} : { runtimeOnly },
+    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
+    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
+    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
+    // so this is the channel.
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    parse(input, pos = 0) {
+      return runOnce(input, pos, createParseContext());
+    },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return runOnce(input, pos, parseCtx);
+    },
+    /**
+     * NO LONGER REFUSES. It used to throw unless the caller passed
+     * `{ recovery: true }`, because setting `_tolerant` on a table with no
+     * recovery rows would report a clean parse with an empty error list whatever
+     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
+     * was the wrong question. `compile()` requires no such flag, so the refusal
+     * was a `CompiledParser` contract break; recovery is now always lowered and
+     * there is nothing left to refuse.
+     */
+    parseWithErrors(input, pos = 0) {
+      const ctx = createParseContext();
+      const errors = [];
+      ctx._errors = errors;
+      ctx._tolerant = true;
+      const r = runOnce(input, pos, ctx);
+      return { ...r, errors };
+    }
+  };
+}
+
 // src/table/fold.ts
 function tableVariants(source, name) {
   const folded = "base" in source ? source : expandCompactFolded(source);