parseman 0.14.1 → 0.16.0

package/dist/index.js

@@ -27,6 +27,63 @@ function any() {
 function empty() {
   return { kind: "empty" };
 }
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const me = (c) => matchesEmpty(c, seen);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length === 0;
+    case "keywords":
+      return false;
+    case "regex":
+      try {
+        const m = new RegExp(d.source).exec("");
+        return m != null && m[0] === "";
+      } catch {
+        return true;
+      }
+    case "many":
+    case "optional":
+    case "not":
+      return true;
+    // zero repetitions / absent / lookahead
+    case "oneOrMore":
+      return me(d.parser);
+    case "sequence":
+      return d.parsers.every(me);
+    case "choice":
+      return d.parsers.some(me);
+    case "transform":
+    case "label":
+    case "trivia":
+    case "expect":
+    case "withCtx":
+    case "node":
+    case "grammar":
+    case "recover":
+      return me(d.parser);
+    case "skip":
+      return me(d.main);
+    case "lazy":
+      try {
+        return me(d.thunk());
+      } catch {
+        return true;
+      }
+    default:
+      return true;
+  }
+}
+function sequenceFirstSet(parsers) {
+  let fs = empty();
+  for (const p of parsers) {
+    fs = union(fs, p._meta.firstSet);
+    if (!matchesEmpty(p)) return fs;
+  }
+  return fs;
+}
 function mergeRanges(ranges) {
   if (ranges.length === 0) return [];
   const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
@@ -204,12 +261,16 @@ function pushTriviaLogEntry(ctx, start, end, kindIndex) {
 }
 
 // src/combinators/literal.ts
-var _collatorCache = null;
-function collator() {
-  if (_collatorCache === null) {
-    _collatorCache = new Intl.Collator(void 0, { sensitivity: "accent" });
+function asciiFoldEq(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    let ca = a.charCodeAt(i);
+    let cb = b.charCodeAt(i);
+    if (ca >= 65 && ca <= 90) ca += 32;
+    if (cb >= 65 && cb <= 90) cb += 32;
+    if (ca !== cb) return false;
   }
-  return _collatorCache;
+  return true;
 }
 function literal(value, opts = {}) {
   const caseInsensitive = opts.caseInsensitive ?? false;
@@ -224,8 +285,9 @@ function literal(value, opts = {}) {
     const lower = value.toLowerCase();
     const firstUpper = upper.codePointAt(0);
     const firstLower = lower.codePointAt(0);
-    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? { kind: "ranges", ranges: [
-      { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }
+    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
+      { lo: firstLower, hi: firstLower },
+      { lo: firstUpper, hi: firstUpper }
     ] } : firstSet;
   }
   return {
@@ -238,7 +300,7 @@ function literal(value, opts = {}) {
         return failAt(ctx, [JSON.stringify(value)], pos);
       }
       const slice = input.slice(pos, end);
-      const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
+      const matched = caseInsensitive ? asciiFoldEq(slice, value) : slice === value;
       if (matched) {
         const span = { start: pos, end };
         const leaf = { _tag: "leaf", value: slice, span };
@@ -848,16 +910,19 @@ function scanTrivia(input, cur, ctx) {
 // src/combinators/sequence.ts
 function sequence(...parsers) {
   const meta = {
-    firstSet: parsers[0]?._meta.firstSet ?? empty(),
+    // Union through the nullable prefix — a leading optional()/many() lets a later
+    // term's first char start the sequence. Just `parsers[0]` under-approximates.
+    firstSet: sequenceFirstSet(parsers),
     canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
     isTrivia: false
   };
+  const def = { tag: "sequence", parsers };
   return {
     _tag: "sequence",
     _meta: meta,
-    _def: { tag: "sequence", parsers },
+    _def: def,
     parse(input, pos, ctx) {
-      const values = [];
+      const values = def.valueUnused ? void 0 : [];
       let cur = pos;
       for (let i = 0; i < parsers.length; i++) {
         if (ctx.trivia && i > 0) {
@@ -877,17 +942,18 @@ function sequence(...parsers) {
           } else {
             rollbackTrivia(ctx, mark);
           }
-          values.push(result2.value);
+          if (values !== void 0) values.push(result2.value);
           continue;
         }
         const result = parsers[i].parse(input, cur, ctx);
         if (!result.ok) return result;
-        values.push(result.value);
+        if (values !== void 0) values.push(result.value);
         cur = result.span.end;
       }
       return {
         ok: true,
-        value: values,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        value: values ?? void 0,
         span: { start: pos, end: cur }
       };
     }
@@ -928,20 +994,21 @@ function many(combinator) {
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
+  const def = { tag: "many", parser: combinator, min: 0 };
   return {
     _tag: "many",
     _meta: meta,
-    _def: { tag: "many", parser: combinator, min: 0 },
+    _def: def,
     parse(input, pos, ctx) {
-      const values = [];
+      const values = def.valueUnused ? void 0 : [];
       let cur = pos;
       while (cur < input.length) {
         const item = repItem(combinator, input, cur, ctx);
         if (item === "stop" || "fail" in item) break;
-        values.push(item.value);
+        if (values !== void 0) values.push(item.value);
         cur = item.end;
       }
-      return { ok: true, value: values, span: { start: pos, end: cur } };
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
   };
 }
@@ -951,22 +1018,23 @@ function oneOrMore(combinator) {
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
+  const def = { tag: "oneOrMore", parser: combinator, min: 1 };
   return {
     _tag: "oneOrMore",
     _meta: meta,
-    _def: { tag: "oneOrMore", parser: combinator, min: 1 },
+    _def: def,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       if (!first.ok) return first;
-      const values = [first.value];
+      const values = def.valueUnused ? void 0 : [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
         const item = repItem(combinator, input, cur, ctx);
         if (item === "stop" || "fail" in item) break;
-        values.push(item.value);
+        if (values !== void 0) values.push(item.value);
         cur = item.end;
       }
-      return { ok: true, value: values, span: { start: pos, end: cur } };
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
   };
 }
@@ -1074,6 +1142,90 @@ function ref() {
   return slot;
 }
 
+// src/compiler/value-usage.ts
+function markUnusedValues(root) {
+  const seenConsumed = /* @__PURE__ */ new WeakSet();
+  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
+  const mark = (def, consumed) => {
+    if (consumed) def.valueUnused = false;
+    else if (def.valueUnused !== false) def.valueUnused = true;
+  };
+  const visit = (c, consumed) => {
+    const seen = consumed ? seenConsumed : seenUnconsumed;
+    if (seen.has(c)) return;
+    seen.add(c);
+    const def = c._def;
+    switch (def.tag) {
+      case "many":
+      case "oneOrMore":
+        mark(def, consumed);
+        visit(def.parser, consumed);
+        return;
+      case "optional":
+        visit(def.parser, consumed);
+        return;
+      case "sequence":
+        mark(def, consumed);
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "choice":
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "node":
+        visit(def.parser, false);
+        return;
+      case "transform":
+        visit(def.parser, true);
+        return;
+      case "skip":
+        visit(def.main, consumed);
+        visit(def.skipped, false);
+        return;
+      case "sepBy":
+        visit(def.parser, true);
+        visit(def.separator, false);
+        return;
+      case "not":
+        visit(def.parser, false);
+        return;
+      case "grammar":
+        visit(def.parser, consumed);
+        if (def.triviaParser) visit(def.triviaParser, false);
+        return;
+      case "recover":
+        visit(def.parser, consumed);
+        visit(def.sentinel, false);
+        return;
+      case "label":
+      case "trivia":
+      case "withCtx":
+      case "expect":
+        visit(def.parser, consumed);
+        return;
+      case "lazy":
+        return;
+      default:
+        return;
+    }
+  };
+  const resolveRoot = (c) => {
+    const guard2 = /* @__PURE__ */ new Set();
+    let cur = c;
+    while (!guard2.has(cur)) {
+      const d = cur._def;
+      if (d.tag !== "lazy") return cur;
+      guard2.add(cur);
+      try {
+        cur = d.thunk();
+      } catch {
+        return c;
+      }
+    }
+    return cur;
+  };
+  visit(resolveRoot(root), true);
+}
+
 // src/combinators/parser.ts
 function rules(factory) {
   const cache = {};
@@ -1103,6 +1255,9 @@ function rules(factory) {
       cache[key] = parser2;
     }
   }
+  for (const key of Object.keys(definitions)) {
+    markUnusedValues(cache[key]);
+  }
   return cache;
 }
 
@@ -1319,7 +1474,12 @@ function parser(opts, root) {
 function noTrivia(root) {
   return parser({ trivia: null }, root);
 }
+var _analyzed = /* @__PURE__ */ new WeakSet();
 function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
   const trackLines = opts.trackLines ?? false;
   const _errors = opts.recover ? [] : void 0;
   const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
@@ -1474,8 +1634,8 @@ function classToRanges(cls) {
   return parseClassRanges(body);
 }
 var foldEq = (cVar, cp) => {
-  if (cp >= 65 && cp <= 90) return `(${cVar} === ${cp} || ${cVar} === ${cp + 32})`;
-  if (cp >= 97 && cp <= 122) return `(${cVar} === ${cp} || ${cVar} === ${cp - 32})`;
+  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`;
+  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`;
   return `${cVar} === ${cp}`;
 };
 function literalCodePoints(frag) {
@@ -1726,6 +1886,12 @@ function firstSetsDisjoint(a, b) {
   return classDisjoint(a, b);
 }
 function fixedClassSeq(shape) {
+  if (shape.kind === "litFold") {
+    return shape.open.map((cp) => {
+      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp;
+      return other === cp ? { ranges: [[cp, cp]], negated: false } : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]], negated: false };
+    });
+  }
   if (shape.kind !== "seq") return null;
   const out = [];
   for (const p of shape.parts) {
@@ -2147,12 +2313,34 @@ function parseScanShapeCore(source) {
 }
 function scanShapeFromRegex(source, flags) {
   if (/[msu]/.test(flags)) return null;
-  if (/i/.test(flags)) {
-    const open = literalCodePoints(source);
-    return open ? { kind: "litFold", open } : null;
-  }
+  if (/i/.test(flags)) return caseFoldShape(source);
   return parseScanShape(source);
 }
+function caseFoldShape(source) {
+  const la = stripTrailingLookahead(source);
+  if (la) {
+    const inner = caseFoldLiteralOrAlt(la.base);
+    if (!inner) return null;
+    const operand = { ranges: la.ranges, negated: la.classNegated };
+    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null;
+    return { kind: "lookahead", inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative };
+  }
+  return caseFoldLiteralOrAlt(source);
+}
+function caseFoldLiteralOrAlt(source) {
+  const asciiOnly = (cps) => cps.every((cp) => cp <= 127);
+  const open = literalCodePoints(source);
+  if (open) return asciiOnly(open) ? { kind: "litFold", open } : null;
+  const arms = splitTopLevelAlternation(source);
+  if (!arms || arms.length < 2) return null;
+  const litArms = [];
+  for (const arm of arms) {
+    const cp = literalCodePoints(arm);
+    if (!cp || !asciiOnly(cp)) return null;
+    litArms.push({ kind: "litFold", open: cp });
+  }
+  return { kind: "alt", arms: litArms, disjoint: false, firsts: litArms.map(() => null) };
+}
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
 var litCond = (base, cps, firstVar) => cps.map(
   (cp, k) => k === 0 && firstVar ? `${firstVar} === ${cp}` : `input.charCodeAt(${base}${k ? ` + ${k}` : ""}) === ${cp}`
@@ -2164,6 +2352,25 @@ function stringHardStop(shape) {
   );
 }
 var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
+var ALT_SWITCH_RANGE_LIMIT = 4;
+var ALT_SWITCH_MAX_CASES = 48;
+var ALT_SWITCH_MIN_CASES = 3;
+function planAltSwitch(firsts) {
+  const cases = [];
+  let total = 0;
+  for (const fs of firsts) {
+    if (!fs || fs.negated) return { kind: "if" };
+    const pts = [];
+    for (const [lo, hi] of fs.ranges) {
+      if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: "if" };
+      for (let cp = lo; cp <= hi; cp++) pts.push(cp);
+    }
+    total += pts.length;
+    if (total > ALT_SWITCH_MAX_CASES) return { kind: "if" };
+    cases.push(pts);
+  }
+  return total >= ALT_SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
+}
 function emitShapeMatch(shape, start, mint, ind2, firstChar) {
   if (shape.kind === "lookahead") {
     const inner = emitShapeMatch(shape.inner, start, mint, ind2, firstChar);
@@ -2188,18 +2395,57 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
     const okV = mint("_ok");
     const endV2 = mint("_end");
     const lines = [`${ind2}let ${okV} = false`, `${ind2}let ${endV2} = ${start}`];
+    if (shape.arms.length >= 2 && shape.arms.every((a) => a.kind === "litFold" && a.open.length >= 1)) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const a of shape.arms) {
+        const open = a.open;
+        const f = open[0];
+        const lower = f >= 65 && f <= 90 ? f + 32 : f;
+        (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
+      }
+      lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      for (const [lower, arms] of groups) {
+        const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
+        lines.push(`${ind2}  ${labels} {`);
+        for (const open of arms) {
+          const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
+          const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
+          lines.push(`${ind2}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+        }
+        lines.push(`${ind2}    break`);
+        lines.push(`${ind2}  }`);
+      }
+      lines.push(`${ind2}}`);
+      return { setup: lines, ok: okV, end: endV2 };
+    }
     if (shape.disjoint) {
-      const c0 = codeAt(start, firstChar);
-      shape.arms.forEach((arm, k) => {
-        const fs = shape.firsts[k];
-        const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
-        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
-        lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-        lines.push(...m.setup);
-        lines.push(`${ind2}  ${okV} = ${m.ok}`);
-        lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+      const plan = planAltSwitch(shape.firsts);
+      if (plan.kind === "switch") {
+        lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        shape.arms.forEach((arm, k) => {
+          const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
+          const m = emitShapeMatch(arm, start, mint, `${ind2}    `, firstChar);
+          lines.push(`${ind2}  ${labels} {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}    ${okV} = ${m.ok}`);
+          lines.push(`${ind2}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}    break`);
+          lines.push(`${ind2}  }`);
+        });
         lines.push(`${ind2}}`);
-      });
+      } else {
+        const c0 = codeAt(start, firstChar);
+        shape.arms.forEach((arm, k) => {
+          const fs = shape.firsts[k];
+          const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
+          const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+          lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}  ${okV} = ${m.ok}`);
+          lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}}`);
+        });
+      }
     } else {
       const lbl = mint("_alt");
       lines.push(`${ind2}${lbl}: {`);
@@ -2687,6 +2933,8 @@ function tryInlineDestructureTransform(src, valueVars) {
 }
 
 // src/compiler/codegen.ts
+var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
+var _loweringSink = null;
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
 }
@@ -3085,13 +3333,14 @@ function emitLit(def, ctx, pos) {
   const vv = v(ctx);
   const expectedStr = JSON.stringify(JSON.stringify(value));
   const stmts = [];
-  if (caseInsensitive) {
-    ctx.needsCollator = true;
+  if (caseInsensitive && len > 0) {
+    const match = Array.from(
+      { length: len },
+      (_, i) => `(${foldEq(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""})`, value.charCodeAt(i))})`
+    ).join(" && ");
     stmts.push(
-      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,
-      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv} = ${vv}_s`
+      ...emitIfFail(ctx, `${pos} + ${len} > input.length || !(${match})`, failBody(ctx, expectedStr, pos)),
+      `${ind(ctx)}const ${vv} = input.slice(${pos}, ${pos} + ${len})`
     );
   } else if (len === 0) {
     stmts.push(`${ind(ctx)}const ${vv} = ''`);
@@ -3212,6 +3461,7 @@ function emitRegex(def, ctx, pos) {
       return { stmts: stmts2, valueVar: vv2, endVar: scanned.endVar };
     }
   }
+  _loweringSink?.add(`/${def.source}/${def.flags}`);
   const flags = "y" + def.flags.replace(/[gy]/g, "");
   const key = `${def.source}/${flags}`;
   let rName = ctx.regexMap.get(key);
@@ -3276,6 +3526,7 @@ function emitSeqValues(def, ctx, pos) {
 }
 function emitSeq(def, ctx, pos) {
   const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos);
+  if (def.valueUnused) return { stmts, valueVar: "undefined", endVar };
   const arrV = v(ctx, "_arr");
   stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(", ")}]`);
   return { stmts, valueVar: arrV, endVar };
@@ -3482,7 +3733,8 @@ function emitFirstMatch(def, ctx, pos) {
     const autoNot = def.autoNot[i];
     const atStart = failsAtStart(p);
     const staticFx = armStaticExpected(ctx, p);
-    const fsGuard = needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null;
+    const deferRuleName = ctx.deferFirstSetRefs ? p._ruleName : void 0;
+    const fsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null;
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
@@ -3573,19 +3825,18 @@ function emitLiteralCondition(litVal, pos) {
   return checks.join(" && ");
 }
 function emitMany(def, ctx, pos) {
+  const wantValue = !def.valueUnused;
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
   const stmts = [
-    `${ind(ctx)}const ${arrV} = []`,
+    ...wantValue ? [`${ind(ctx)}const ${arrV} = []`] : [],
     `${ind(ctx)}let ${curV} = ${pos}`
   ];
   if (def.min === 1) {
     const firstR = emit(def.parser, ctx, curV);
     stmts.push(...firstR.stmts);
-    stmts.push(
-      `${ind(ctx)}${arrV}.push(${firstR.valueVar})`,
-      `${ind(ctx)}${curV} = ${firstR.endVar}`
-    );
+    if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${firstR.valueVar})`);
+    stmts.push(`${ind(ctx)}${curV} = ${firstR.endVar}`);
   }
   stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
   ctx.indent++;
@@ -3616,13 +3867,13 @@ function emitMany(def, ctx, pos) {
   const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true);
   stmts.push(
     ...iterStmts,
-    `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`,
-    `${ind(ctx)}${arrV}.push(${iterVal})`,
-    `${ind(ctx)}${curV} = ${iterEnd}`
+    `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`
   );
+  if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${iterVal})`);
+  stmts.push(`${ind(ctx)}${curV} = ${iterEnd}`);
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
-  return { stmts, valueVar: arrV, endVar: curV };
+  return { stmts, valueVar: wantValue ? arrV : "undefined", endVar: curV };
 }
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
@@ -3791,15 +4042,19 @@ function emitNode(def, ctx, pos) {
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || structural || buildReadsTrivia(def);
-  const clonesState = structural || buildReadsState(def);
+  const capturesTrivia = mkType !== null || !structural && buildReadsTrivia(def);
+  const clonesState = !structural && buildReadsState(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
-  const tlV = capturesTrivia ? v(ctx, "_tl") : "_EMPTY_TL";
+  const capTLv = structural ? v(ctx, "_ctl") : null;
+  const capSTv = structural ? v(ctx, "_cst") : null;
+  const tlV = capturesTrivia || structural ? v(ctx, "_tl") : "_EMPTY_TL";
   if (!capturesTrivia) ctx.needsEmptyTl = true;
   const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st"), stl = v(ctx, "_stl");
-  const allocStmt = capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
-  const innerTl = capturesTrivia ? tlV : "undefined";
+  if (structural) ctx.needsHostReads = true;
+  const allocStmt = structural ? `${i}const ${capTLv} = _ctx._pmCapTL ??= _hostReads(_ctx.build, 4), ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 5))
+${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL` : capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
+  const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : "undefined";
   const stmts = [
     allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
@@ -3810,7 +4065,10 @@ function emitNode(def, ctx, pos) {
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
   let stV = "undefined";
-  if (clonesState) {
+  if (structural) {
+    stV = v(ctx, "_nst");
+    stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+  } else if (clonesState) {
     stV = v(ctx, "_nst");
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
@@ -4232,6 +4490,7 @@ function ruleDependencies(ruleMap) {
   return deps;
 }
 function compile(combinator, mapFnSources) {
+  markUnusedValues(combinator);
   const ctx = {
     vars: 0,
     indent: 1,
@@ -4245,7 +4504,6 @@ function compile(combinator, mapFnSources) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4254,18 +4512,18 @@ function compile(combinator, mapFnSources) {
     lazyUsage: analyzeLazyUsage(combinator)
   };
   const r = emit(combinator, ctx, "_pos");
-  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
-` : "";
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
+  const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
   const source = [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     "",
     ...namedPrelude,
     ctx.namedFnDecls.join("\n\n"),
-    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
+    `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
     ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
@@ -4273,9 +4531,9 @@ function compile(combinator, mapFnSources) {
   ].join("\n");
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
-    collatorDecl,
     ...namedPrelude,
     ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
     `let pos = _pos`,
@@ -4292,7 +4550,7 @@ function compile(combinator, mapFnSources) {
   const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
   const mfCovered = ctx.mapFns.length === 0 || effectiveSources !== void 0 && effectiveSources.length === ctx.mapFns.length;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
-  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources) : null;
   return {
     source,
     inlineExpression,
@@ -4314,8 +4572,17 @@ function compile(combinator, mapFnSources) {
     }
   };
 }
+var RULE_NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function assertRuleName(name) {
+  if (!RULE_NAME_RE.test(name)) {
+    throw new Error(
+      `parseman: grammar rule name ${JSON.stringify(name)} is not a valid JS identifier. Rule names compile to _r_<Name> functions and dispatch guards \u2014 use letters, digits, _ or $ (and don't start with a digit).`
+    );
+  }
+}
 function compileLinkable(ruleMapArg, ns) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
+  for (const [, rule] of ruleMapArg) markUnusedValues(rule);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -4339,20 +4606,21 @@ function compileLinkable(ruleMapArg, ns) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
     namedFnDecls: [],
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
-    ns
+    ns,
+    deferFirstSetRefs: true
   };
   const seen = /* @__PURE__ */ new Map();
   const ruleNames = /* @__PURE__ */ new Map();
   const fnNameToKey = /* @__PURE__ */ new Map();
   for (const [key, rule] of ruleMap) {
-    const base = `_r_${key.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+    assertRuleName(key);
+    const base = `_r_${key}`;
     const n = seen.get(base) ?? 0;
     seen.set(base, n + 1);
     const fn = n === 0 ? base : `${base}$${n}`;
@@ -4376,7 +4644,8 @@ function compileLinkable(ruleMapArg, ns) {
         if (resolved === void 0) {
           const name = p._ruleName;
           if (name && !ctx.namedParsers.has(p)) {
-            const fn = `_r_${name.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+            assertRuleName(name);
+            const fn = `_r_${name}`;
             ruleNames.set(p, fn);
             ctx.namedParsers.set(p, fn);
           }
@@ -4445,20 +4714,34 @@ function compileLinkable(ruleMapArg, ns) {
       `}`
     ].join("\n"));
   }
+  const firstSets = /* @__PURE__ */ new Map();
+  for (const [key, rule] of ruleMap) {
+    let resolved = rule;
+    const d = rule._def;
+    if (d.tag === "lazy") {
+      try {
+        resolved = d.thunk();
+      } catch {
+        resolved = rule;
+      }
+    }
+    firstSets.set(key, canMatchEmptyAtStart(resolved) ? { kind: "any" } : resolved._meta.firstSet);
+  }
   return {
     ns,
     keys: perEntry.map((e) => e.key),
     prelude,
     ruleFns,
     wrappers,
+    firstSets,
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
-    needsCollator: ctx.needsCollator,
+    needsHostReads: !!ctx.needsHostReads,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
+function buildInlineExpression(ctx, r, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
     ...r.stmts,
@@ -4472,14 +4755,15 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
+  const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
+    hostReadsDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
-    collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
     ...namedPrelude.map((l) => `  ${l}`),
@@ -4538,20 +4822,36 @@ function fusedBody(pieces) {
   }
   const contributing = new Set(winner.values());
   const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
-  const needsCollator = [...contributing].some((p) => p.needsCollator);
+  const needsHostReads = [...contributing].some((p) => p.needsHostReads);
   const lines = [
     // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
     "const _pfFail = {}",
     "let _pfEnd",
     ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
-    ...needsCollator ? ["const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })"] : [],
+    ...needsHostReads ? [HOST_READS_DECL] : [],
     // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
     ...[...contributing].flatMap((p) => p.prelude),
     // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
-  const body = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  const rawBody = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  const finalFS = /* @__PURE__ */ new Map();
+  for (const [k, p] of winner) {
+    const fs = p.firstSets?.get(k);
+    if (fs) finalFS.set(k, fs);
+  }
+  const body = rawBody.replace(
+    // Rule name + code-point var are both JS identifiers (rule names are validated
+    // at compile time — see assertRuleName in codegen), so an identifier class
+    // matches every well-formed placeholder.
+    /\/\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\*\/true/g,
+    (_m, name, codevar) => {
+      const fs = finalFS.get(name);
+      if (!fs || fs.kind === "any" || fs.kind === "empty") return "true";
+      return `(${firstSetCond(codevar, fs)})`;
+    }
+  );
   const env = {};
   for (const p of contributing) {
     if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;