parseman 0.58.2 → 0.58.3

package/dist/table/index.js

@@ -1,3 +1,32 @@
+// src/lead-ranges.ts
+function rangesHaveLead(ranges, code) {
+  for (const r of ranges) if (code >= r.lo && code <= r.hi) return true;
+  if (code <= 65535) return false;
+  const high = 55296 + (code - 65536 >> 10);
+  for (const r of ranges) if (high >= r.lo && high <= r.hi) return true;
+  return false;
+}
+function leadRanges(ranges) {
+  let out;
+  for (const r of ranges) {
+    const lo = Math.max(r.lo, 55296), hi = Math.min(r.hi, 56319);
+    if (lo <= hi) (out ??= [...ranges]).push({ lo: 65536 + (lo - 55296 << 10), hi: 65536 + (hi - 55296 << 10) + 1023 });
+  }
+  return out ?? ranges;
+}
+function implicitLeadsDropped(ranges) {
+  const implied = leadRanges(ranges.filter((r) => r.lo <= 65535)).filter((r) => r.lo > 65535);
+  const out = [];
+  for (const r of ranges) {
+    let pieces = [{ lo: r.lo, hi: r.hi }];
+    if (r.hi > 65535) for (const c of implied) {
+      pieces = pieces.flatMap((q2) => q2.hi < c.lo || q2.lo > c.hi ? [q2] : [...q2.lo < c.lo ? [{ lo: q2.lo, hi: c.lo - 1 }] : [], ...q2.hi > c.hi ? [{ lo: c.hi + 1, hi: q2.hi }] : []]);
+    }
+    out.push(...pieces);
+  }
+  return out;
+}
+
 // src/combinators/first-set.ts
 function classifyFinalChoice(arms, resolve, activeTrivia) {
   const firstSets = [];
@@ -59,8 +88,9 @@ function union(a, b) {
 function intersects(a, b) {
   if (a.kind === "any" || b.kind === "any") return true;
   if (a.kind === "empty" || b.kind === "empty") return false;
-  for (const ra of a.ranges) {
-    for (const rb of b.ranges) {
+  const bs = leadRanges(b.ranges);
+  for (const ra of leadRanges(a.ranges)) {
+    for (const rb of bs) {
       if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
     }
   }
@@ -76,6 +106,9 @@ function startsFirstSet(combinator, input, pos) {
   const code = input.codePointAt(pos);
   if (code === void 0) return false;
   for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  if (code <= 65535) return false;
+  const high = 55296 + (code - 65536 >> 10);
+  for (const r of fs.ranges) if (high >= r.lo && high <= r.hi) return true;
   return false;
 }
 function fromRange(lo, hi) {
@@ -176,12 +209,13 @@ function narrowBy(acc, constraint) {
   if (acc.kind === "any") return constraint;
   if (acc.kind === "empty" || constraint.kind === "empty") return { kind: "empty" };
   const ranges = [];
-  for (const a of acc.ranges) for (const b of constraint.ranges) {
+  const bs = leadRanges(constraint.ranges);
+  for (const a of leadRanges(acc.ranges)) for (const b of bs) {
     const lo = Math.max(a.lo, b.lo);
     const hi = Math.min(a.hi, b.hi);
     if (lo <= hi) ranges.push({ lo, hi });
   }
-  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges: implicitLeadsDropped(ranges) };
 }
 function applyAssertion(fs, assertion) {
   return assertion === null ? fs : fs.kind === "empty" ? assertion : narrowBy(fs, assertion);
@@ -806,11 +840,17 @@ function shorthandRanges(ch2) {
   if (ch2 === "s") return SPACE_RANGES;
   return [[48, 57], [65, 90], [97, 122], [95, 95]];
 }
-function readUnicodeEscape(body, i) {
+function readUnicodeEscape(body, i, unicode = false) {
   if (body[i] !== "\\" || body[i + 1] !== "u") return null;
   const hex = body.slice(i + 2, i + 6);
   if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
-  return { cp: Number.parseInt(hex, 16), next: i + 6 };
+  const cp = Number.parseInt(hex, 16);
+  if (unicode && cp >= 55296 && cp <= 56319 && body[i + 6] === "\\" && body[i + 7] === "u") {
+    const lowHex = body.slice(i + 8, i + 12);
+    const low = /^[0-9a-fA-F]{4}$/.test(lowHex) ? Number.parseInt(lowHex, 16) : -1;
+    if (low >= 56320 && low <= 57343) return { cp: 65536 + (cp - 55296 << 10) + (low - 56320), next: i + 12 };
+  }
+  return { cp, next: i + 6 };
 }
 var META = new Set("()[]{}*+?|^$.".split(""));
 function literalCodePoints(frag) {
@@ -822,6 +862,7 @@ function literalCodePoints(frag) {
       const e = frag[i + 1];
       if (e === void 0) return null;
       if (!(e in CLASS_ESCAPES) && /\w/.test(e)) return null;
+      if (e === "0" && frag[i + 2] !== void 0 && frag[i + 2] >= "0" && frag[i + 2] <= "9") return null;
       out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
@@ -862,14 +903,14 @@ function parseClassOperand(body) {
   if (cps && cps.length === 1) return { ranges: [[cps[0], cps[0]]], negated: false };
   return null;
 }
-function parseClassRanges(body) {
+function parseClassRanges(body, unicode = false) {
   const ranges = [];
   let i = 0;
   const readAtom = () => {
     const ch2 = body[i];
     if (ch2 === void 0) return null;
     if (ch2 === "\\") {
-      const uni = readUnicodeEscape(body, i);
+      const uni = readUnicodeEscape(body, i, unicode);
       if (uni) {
         i = uni.next;
         return { cp: uni.cp };
@@ -877,13 +918,15 @@ function parseClassRanges(body) {
       const e = body[i + 1];
       if (e === void 0) return null;
       i += 2;
+      if (e === "0" && body[i] !== void 0 && body[i] >= "0" && body[i] <= "9" || e >= "1" && e <= "9") return null;
       if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
       if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
       if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       return { cp: e.codePointAt(0) };
     }
-    i += ch2.length;
-    return { cp: ch2.codePointAt(0) };
+    const cp = unicode ? body.codePointAt(i) : body.charCodeAt(i);
+    i += cp > 65535 ? 2 : 1;
+    return { cp };
   };
   while (i < body.length) {
     const lo = readAtom();
@@ -1586,9 +1629,7 @@ function firstSetSentinel(fs) {
     parse(input, pos) {
       const code = pos < input.length ? input.codePointAt(pos) : void 0;
       if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
+        if (rangesHaveLead(ranges, code)) return { ok: true, value: null, span: { start: pos, end: pos } };
       }
       return { ok: false, expected: [], span: { start: pos, end: pos } };
     }
@@ -2673,6 +2714,9 @@ function inFirstSet(code, fs) {
   if (fs.kind === "any") return true;
   if (fs.kind === "empty") return false;
   for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  if (code <= 65535) return false;
+  const high = 55296 + (code - 65536 >> 10);
+  for (const r of fs.ranges) if (high >= r.lo && high <= r.hi) return true;
   return false;
 }
 function areDisjoint(sets) {
@@ -3016,7 +3060,7 @@ function rangesHaveNewline(ranges) {
   return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
 }
 var BAIL = /* @__PURE__ */ Symbol("regex-bail");
-function parseRegex(src) {
+function parseRegex(src, unicode = false, sets = false) {
   let i = 0;
   const parseAlt = () => {
     const arms = [parseSeq()];
@@ -3086,9 +3130,11 @@ function parseRegex(src) {
         i++;
         return charNode(fromRange(123, 123), false);
       // a `{` with nothing to quantify is a literal brace
-      default:
-        i += ch2.length;
-        return charNode(fromRange(ch2.codePointAt(0), ch2.codePointAt(0)), ch2 === "\n");
+      default: {
+        const cp = unicode ? src.codePointAt(i) : src.charCodeAt(i);
+        i += cp > 65535 ? 2 : 1;
+        return charNode(fromRange(cp, cp), ch2 === "\n");
+      }
     }
   };
   const parseGroup = () => {
@@ -3121,6 +3167,32 @@ function parseRegex(src) {
     let k = i + 1;
     const negated = src[k] === "^";
     if (negated) k++;
+    if (sets) {
+      let depth = 1;
+      let nested = false;
+      while (k < src.length && depth > 0) {
+        const c = src[k];
+        if (c === "\\") {
+          if (src[k + 1] === "q") nested = true;
+          k += 2;
+          continue;
+        }
+        if (c === "[") {
+          depth++;
+          nested = true;
+        } else if (c === "]") {
+          depth--;
+          if (depth === 0) break;
+        } else if ((c === "-" || c === "&") && src[k + 1] === c) nested = true;
+        k++;
+      }
+      if (src[k] !== "]") throw BAIL;
+      if (nested) {
+        i = k + 1;
+        return charNode(any(), true);
+      }
+      k = i + 1 + (negated ? 1 : 0);
+    }
     let body = "";
     while (k < src.length && src[k] !== "]") {
       if (src[k] === "\\") {
@@ -3133,7 +3205,7 @@ function parseRegex(src) {
     }
     if (src[k] !== "]") throw BAIL;
     i = k + 1;
-    const ranges = parseClassRanges(body);
+    const ranges = parseClassRanges(body, unicode);
     if (negated) return charNode(any(), !ranges || !rangesHaveNewline(ranges));
     if (!ranges) return charNode(any(), true);
     return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
@@ -3141,9 +3213,20 @@ function parseRegex(src) {
   const parseEscape = () => {
     const e = src[i + 1];
     if (e === void 0) throw BAIL;
-    if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
-      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
-      i += 6;
+    const uni = readUnicodeEscape(src, i, unicode);
+    if (uni !== null) {
+      i = uni.next;
+      return charNode(fromRange(uni.cp, uni.cp), uni.cp === 10);
+    }
+    if (e === "u" && src[i + 2] === "{") {
+      const close = src.indexOf("}", i + 3);
+      const hex = close < 0 ? "" : src.slice(i + 3, close);
+      if (!unicode || !/^[0-9a-fA-F]{1,6}$/.test(hex)) {
+        i += 2;
+        return ANY;
+      }
+      const cp = Number.parseInt(hex, 16);
+      i = close + 1;
       return charNode(fromRange(cp, cp), cp === 10);
     }
     if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
@@ -3151,6 +3234,16 @@ function parseRegex(src) {
       i += 4;
       return charNode(fromRange(cp, cp), cp === 10);
     }
+    if (e === "c") {
+      const x = src[i + 2];
+      if (x !== void 0 && /^[A-Za-z]$/.test(x)) {
+        const cp = x.charCodeAt(0) % 32;
+        i += 3;
+        return charNode(fromRange(cp, cp), cp === 10);
+      }
+      i += 2;
+      return ANY;
+    }
     i += 2;
     switch (e) {
       case "d":
@@ -3178,8 +3271,16 @@ function parseRegex(src) {
         return charNode(fromRange(12, 12), false);
       case "v":
         return charNode(fromRange(11, 11), false);
+      // `\0` then a digit is a legacy octal escape (`\012` is a newline), not NUL.
       case "0":
-        return charNode(fromRange(0, 0), false);
+        return src[i] !== void 0 && src[i] >= "0" && src[i] <= "9" ? ANY : charNode(fromRange(0, 0), false);
+      // A property escape (`\p{…}`/`\P{…}`) matches one character of a class this
+      // analyzer does not enumerate; `\k<name>` is a backreference, which may match empty.
+      case "p":
+      case "P":
+        return charNode(any(), true);
+      case "k":
+        return ANY;
       default:
         if (e >= "1" && e <= "9") return ANY;
         return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
@@ -3253,10 +3354,10 @@ function regexCanMatchEmpty(source) {
     return true;
   }
 }
-function firstSetFromRegex(source) {
+function firstSetFromRegex(source, flags = "") {
   let ast;
   try {
-    ast = parseRegex(source);
+    ast = parseRegex(source, flags.includes("u") || flags.includes("v"), flags.includes("v"));
   } catch {
     return { firstSet: any(), canMatchNewline: true };
   }
@@ -3305,8 +3406,18 @@ function shortScanner(source, flags) {
     return minOne && end === pos ? null : end;
   };
 }
+function coversNonAscii(ranges) {
+  let next = 128;
+  for (const r of [...ranges].sort((a, b) => a.lo - b.lo)) {
+    if (r.lo > next) return false;
+    if (r.hi >= next) next = r.hi + 1;
+    if (next > 65535) return true;
+  }
+  return false;
+}
 function asciiCaseFold(fs) {
   if (fs.kind !== "ranges") return fs;
+  if (fs.ranges.some((r) => r.hi >= 128) && !coversNonAscii(fs.ranges)) return any();
   const ranges = fs.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
   const add = (lo, hi) => {
     if (lo <= hi) ranges.push({ lo, hi });
@@ -3331,7 +3442,7 @@ function regex(pattern, flags = "") {
   const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
   const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
   const scan = shortScanner(source, resolvedFlags);
-  const raw = firstSetFromRegex(source);
+  const raw = firstSetFromRegex(source, resolvedFlags);
   const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
   const canMatchNewline = raw.canMatchNewline;
   const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
@@ -4113,7 +4224,7 @@ function decodeClassSpec(spec) {
 function resolveClass(spec) {
   const ascii = new Uint8Array(128);
   const hi = [];
-  for (const { lo, hi: up } of decodeClassSpec(spec)) {
+  for (const { lo, hi: up } of leadRanges(decodeClassSpec(spec))) {
     if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1;
     if (up >= 128) hi.push(Math.max(lo, 128), up);
   }
@@ -5386,6 +5497,15 @@ function skipDeferredTrivia(input, cur, ctx) {
   if (plain) remember(cur, scan, ctx, input, triviaP);
   return scan;
 }
+function triviaLeadTable(triviaP) {
+  const fs = triviaP._meta.firstSet;
+  if (fs.kind === "any") return null;
+  const table = new Uint8Array(128);
+  if (fs.kind === "ranges") {
+    for (const r of fs.ranges) for (let c = Math.max(0, r.lo); c <= Math.min(127, r.hi); c++) table[c] = 1;
+  }
+  return table;
+}
 function clearRunEnd(input, cur, ctx, triviaP, plain) {
   const rootKinds = ctx._rootTriviaKindIndex;
   const spec = triviaP?._meta.labeledTriviaSpec;
@@ -5737,6 +5857,7 @@ function parseSeqParts(source) {
         cp2 = uni.cp;
         i = uni.next;
       } else if (e === void 0) return null;
+      else if (e >= "0" && e <= "9" && (e !== "0" || source[i + 2] !== void 0 && source[i + 2] >= "0" && source[i + 2] <= "9")) return null;
       else if (e in CLASS_ESCAPES) {
         cp2 = CLASS_ESCAPES[e];
         i += 2;
@@ -6286,7 +6407,7 @@ function parseScanShapeCore(source) {
   return null;
 }
 function scanShapeFromRegex(source, flags) {
-  if (/[msu]/.test(flags)) return null;
+  if (/[msuv]/.test(flags)) return null;
   if (/i/.test(flags)) return caseFoldShape(source);
   return parseScanShape(source);
 }
@@ -6891,7 +7012,7 @@ function triviaLeadRanges(tri, trivia2) {
   const fs = trivia2[tri]?._meta.firstSet;
   if (fs === void 0) return void 0;
   if (fs.kind === "empty") return [];
-  return fs.kind === "ranges" && fs.ranges !== void 0 ? fs.ranges : void 0;
+  return fs.kind === "ranges" && fs.ranges !== void 0 ? leadRanges(fs.ranges) : void 0;
 }
 
 // src/table/scalar-terminal.ts
@@ -7421,7 +7542,7 @@ if(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}e
   if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,undefined,undefined,${t}lg,${t}rt)`;
   return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "undefined"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
 }
-function emitTerm(callee, dst, t, l, skip) {
+function emitTerm(callee, dst, t, l, skip, miss) {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
@@ -7439,7 +7560,12 @@ if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
 if(EC.e>${t}s)cur=EC.e
 else{rollbackScannedTriviaAt(ctx,${t}tl,${t}stl,${t}lg,${t}slg,${t}rt,${t}srt)}`;
-  if (l.tri !== TRI_UNKNOWN) return scanned;
+  if (l.tri !== TRI_UNKNOWN) return miss === void 0 ? scanned : `const ${t}c=input.charCodeAt(cur)
+if(${miss(`${t}c`)}){
+${fast}
+}else{
+${scanned}
+}`;
   return `if(ctx.trivia===undefined){
 ${fast}
 }else{
@@ -7495,7 +7621,7 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, select) {
+function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, select, scanSinkNeutral = false) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
@@ -7571,7 +7697,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
     const op = code[ip];
     sinkBits.set(
       ip,
-      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC && (op === OP_REP || op === OP_REPV) ? 2 : 0)
+      op === OP_SCAN || !scanSinkNeutral && op === OP_LEX_PROGRAM && t.lexPrograms[code[ip + 1]].scan !== void 0 ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC && (op === OP_REP || op === OP_REPV) ? 2 : 0)
     );
   }
   const sinkKids = [];
@@ -7744,6 +7870,12 @@ return 1
     return `if(${gateMissTest(child)}){${miss}}
 `;
   }
+  function triviaMiss(ki) {
+    const leads = triviaLeadRanges(ki, t.trivia);
+    if (leads === void 0 || leads.length > 16) return void 0;
+    if (leads.length === 0) return (c) => `${c}<55296`;
+    return (c) => `${c}<55296&&!(${leads.map((r) => r.lo === r.hi ? `${c}===${r.lo}` : `(${c}>=${r.lo}&&${c}<=${r.hi})`).join("||")})`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -7754,8 +7886,13 @@ return 1
     const nm = `_sk${skipPool.size}`;
     skipPool.set(key, nm);
     if (!hasScan) {
-      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return skipDeferredTrivia(input,cur,ctx)}` : `function ${nm}(input,cur,ctx){
-if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
+      const miss = triviaMiss(ki);
+      const pre = miss === void 0 ? "" : `const c=input.charCodeAt(cur)
+if(${miss("c")})return cur
+`;
+      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){${pre === "" ? "" : `
+${pre}`}return skipDeferredTrivia(input,cur,ctx)}` : `function ${nm}(input,cur,ctx){
+${pre}if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)}`);
       return nm;
     }
@@ -8339,7 +8476,7 @@ return v
             );
           } else {
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
-            parts.push(holdsGap(code, k, base, n, i, nullable2) ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L)) : emitTerm(callee, vn, tmp(), L, skipFor(L)));
+            parts.push(holdsGap(code, k, base, n, i, nullable2) ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L)) : emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : void 0));
           }
           names.push(vn);
         }
@@ -9708,7 +9845,23 @@ function assemble(t, prog, cfg) {
     }
     return out;
   }
+  const LEAD_TABLES = trivia2.map((tp) => tp === void 0 ? null : triviaLeadTable(tp));
+  let LEAD_OF;
+  let LEAD_TABLE = null;
+  function cannotStartTrivia(input, cur, triviaP) {
+    if (triviaP !== LEAD_OF) {
+      LEAD_OF = triviaP;
+      const slot = trivia2.indexOf(triviaP);
+      LEAD_TABLE = slot >= 0 ? LEAD_TABLES[slot] : triviaLeadTable(triviaP);
+    }
+    const table = LEAD_TABLE;
+    if (table === null) return false;
+    const c = input.charCodeAt(cur);
+    return c < 128 && table[c] === 0;
+  }
   function skipTrivia(input, cur, ctx) {
+    const t2 = ctx.trivia;
+    if (t2 !== void 0 && cannotStartTrivia(input, cur, t2)) return cur;
     const s = SCAN;
     if (s !== null && ctx._triviaLog === void 0 && !(ctx.captureTrivia === true && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0))) {
       return s(input, cur);
@@ -9723,7 +9876,8 @@ function assemble(t, prog, cfg) {
   const frames = [];
   let depth = 0;
   function nextTerm(child, input, cur, ctx) {
-    if (ctx.trivia === void 0) {
+    const t2 = ctx.trivia;
+    if (t2 === void 0 || cannotStartTrivia(input, cur, t2)) {
       const v2 = child(input, cur, ctx);
       if (v2 === FAIL) return -1;
       TERMV = v2;
@@ -9752,7 +9906,8 @@ function assemble(t, prog, cfg) {
     return cur;
   }
   function nextTermBuffered(child, input, cur, ctx) {
-    if (ctx.trivia === void 0) {
+    const t2 = ctx.trivia;
+    if (t2 === void 0 || cannotStartTrivia(input, cur, t2)) {
       const v2 = child(input, cur, ctx);
       if (v2 === FAIL) return -1;
       TERMV = v2;
@@ -10554,6 +10709,7 @@ function assemble(t, prog, cfg) {
         const scopeTrivia = ki < 0 ? void 0 : trivia2[ki];
         const scopeLabels = scopeTrivia?._meta.triviaKindLabels;
         const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? triviaScan[ki] : null;
+        const scopeLead = ki < 0 ? null : LEAD_TABLES[ki];
         const child = link(code[ip + 2]);
         const scopePiece = code[ip] === OP_SCOPE_CAP ? (input, pos, ctx) => {
           const saved = ctx.trivia;
@@ -10561,6 +10717,9 @@ function assemble(t, prog, cfg) {
           const savedScan = SCAN;
           const savedCap = ctx.captureTrivia;
           SCAN = scanFor;
+          const savedLeadOf = LEAD_OF, savedLead = LEAD_TABLE;
+          LEAD_OF = scopeTrivia;
+          LEAD_TABLE = scopeLead;
           ctx.trivia = scopeTrivia;
           ctx.triviaKindLabels = scopeLabels;
           ctx.captureTrivia = true;
@@ -10569,18 +10728,25 @@ function assemble(t, prog, cfg) {
           ctx.trivia = saved;
           ctx.triviaKindLabels = savedLabels;
           SCAN = savedScan;
+          LEAD_OF = savedLeadOf;
+          LEAD_TABLE = savedLead;
           return v;
         } : (input, pos, ctx) => {
           const saved = ctx.trivia;
           const savedLabels = ctx.triviaKindLabels;
           const savedScan = SCAN;
           SCAN = scanFor;
+          const savedLeadOf = LEAD_OF, savedLead = LEAD_TABLE;
+          LEAD_OF = scopeTrivia;
+          LEAD_TABLE = scopeLead;
           ctx.trivia = scopeTrivia;
           ctx.triviaKindLabels = scopeLabels;
           const v = child(input, pos, ctx);
           ctx.trivia = saved;
           ctx.triviaKindLabels = savedLabels;
           SCAN = savedScan;
+          LEAD_OF = savedLeadOf;
+          LEAD_TABLE = savedLead;
           return v;
         };
         return scopeRootPolicy(scopePiece, code[ip] === OP_SCOPE_PLAIN ? 0 : code[ip + 3]);
@@ -17282,8 +17448,8 @@ function compileRuleMap(ruleMap, opts = {}) {
     const roots = assemblyExtraIps(artifact);
     let siteBytes, fixed;
     try {
-      siteBytes = emitAssemblySource(table, artifact, cfg, roots, true).siteBytes;
-      fixed = emitAssemblySource(table, artifact, cfg, roots, true, /* @__PURE__ */ new Set()).source.length;
+      siteBytes = emitAssemblySource(table, artifact, cfg, roots, true, void 0, true).siteBytes;
+      fixed = emitAssemblySource(table, artifact, cfg, roots, true, /* @__PURE__ */ new Set(), true).source.length;
     } catch (e) {
       if (e instanceof Unemittable) return { ...none, refusal: e.construct };
       throw e;
@@ -17299,7 +17465,7 @@ function compileRuleMap(ruleMap, opts = {}) {
           refusal: `a site within its ${Math.floor(ceiling)} B selection ceiling (the prelude alone is ${fixed} B)`
         };
       }
-      const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites).source.length;
+      const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites, true).source.length;
       if (bytes <= ceiling) return { sites, bytes: Math.ceil(bytes * SUPERCOMPILE_GROWTH) };
       target *= Math.min(ceiling / bytes, 0.99);
     }