parseman 0.53.0 → 0.55.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);
@@ -4070,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);
@@ -6396,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 {
@@ -6470,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
@@ -6730,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);
@@ -7167,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: {
@@ -7470,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");
@@ -7870,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
@@ -8743,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;
   }
@@ -9380,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;
         };
       }
@@ -9414,8 +9449,21 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_WITHCTX: {
-        const extra = k[code[ip + 1]];
+        const ki = code[ip + 1];
         const child = link(code[ip + 2]);
+        if (ki < 0) {
+          const derive2 = fns[~ki];
+          return (input, pos, ctx) => {
+            const saved = ctx.state;
+            ctx.state = derive2(saved);
+            try {
+              return child(input, pos, ctx);
+            } finally {
+              ctx.state = saved;
+            }
+          };
+        }
+        const extra = k[ki];
         return (input, pos, ctx) => {
           const saved = ctx.state;
           ctx.state = extra;
@@ -9819,6 +9867,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);
@@ -9896,9 +9950,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]);
@@ -9906,6 +9963,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;
@@ -10268,7 +10328,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;
@@ -10491,6 +10551,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);
@@ -10652,6 +10781,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;
@@ -10691,6 +10821,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);
@@ -10780,6 +10911,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);
@@ -11102,20 +11234,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);
@@ -11181,7 +11302,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = new Set(pre.reached);
     }
@@ -11263,7 +11386,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = em.reached;
     } catch (e) {
@@ -11439,7 +11564,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);
@@ -11447,7 +11574,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;
@@ -11468,6 +11595,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
@@ -12644,6 +12774,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.
    *
@@ -13264,8 +13404,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];
@@ -13297,6 +13439,9 @@ var Encoder = class {
           this.expected([adjacencyExpected(d)])
         );
       case "withCtx": {
+        if (typeof d.extra === "function") {
+          return this.emit(OP_WITHCTX, ~this.fn(d.extra, d.extraSrc ?? null), this.node(d.parser).ip);
+        }
         if (!emittableConst(d.extra)) {
           this.runtimeOnly.add("withCtx(extra) \u2014 the state object is not serialisable");
         }
@@ -13703,11 +13848,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 = {}) {
@@ -13911,7 +14060,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":