parseman 0.12.0 → 0.13.0

package/dist/plugin/index.cjs

@@ -34,8 +34,10 @@ __export(plugin_exports, {
   transformMacro: () => transformMacro
 });
 module.exports = __toCommonJS(plugin_exports);
+var fs = __toESM(require("node:fs"), 1);
 var import_unplugin = require("unplugin");
 var import_oxc_parser = require("oxc-parser");
+var import_oxc_resolver = require("oxc-resolver");
 var import_magic_string = __toESM(require("magic-string"), 1);
 
 // src/combinators/first-set.ts
@@ -363,15 +365,15 @@ function extractFirstSet(node2) {
     case "Alternative": {
       const exprs = node2.expressions;
       if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
-      let fs = empty();
+      let fs2 = empty();
       let canNL = false;
       for (const expr of exprs) {
         const r = extractFirstSet(expr);
-        fs = union(fs, r.firstSet);
+        fs2 = union(fs2, r.firstSet);
         canNL = canNL || r.canMatchNewline;
         if (!canBeEmpty(expr)) break;
       }
-      return { firstSet: fs, canMatchNewline: canNL };
+      return { firstSet: fs2, canMatchNewline: canNL };
     }
     case "Char": {
       const kind = node2.kind;
@@ -398,22 +400,22 @@ function extractFirstSet(node2) {
     }
     case "CharacterClass": {
       const expressions = node2.expressions;
-      let fs = empty();
+      let fs2 = empty();
       let canNL = false;
       for (const expr of expressions) {
         if (expr.type === "ClassRange") {
           const from = expr.from.codePoint;
           const to = expr.to.codePoint;
-          fs = union(fs, fromRange(from, to));
+          fs2 = union(fs2, fromRange(from, to));
           if (from <= 10 && 10 <= to) canNL = true;
         } else if (expr.type === "Char") {
           const r = extractFirstSet(expr);
-          fs = union(fs, r.firstSet);
+          fs2 = union(fs2, r.firstSet);
           canNL = canNL || r.canMatchNewline;
         }
       }
       if (node2.negative) return { firstSet: any(), canMatchNewline: true };
-      return { firstSet: fs, canMatchNewline: canNL };
+      return { firstSet: fs2, canMatchNewline: canNL };
     }
     case "Repetition": {
       return extractFirstSet(node2.expression);
@@ -722,10 +724,10 @@ function codesToFirstSet(codes) {
   ranges.push({ lo, hi });
   return { kind: "ranges", ranges };
 }
-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;
+function inFirstSet(code, fs2) {
+  if (fs2.kind === "any") return true;
+  if (fs2.kind === "empty") return false;
+  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
   return false;
 }
 function areDisjoint(sets) {
@@ -1374,8 +1376,29 @@ function expect(combinator, label2) {
 var BACKSLASH = 92;
 var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
+var SPACE_RANGES = [
+  [9, 13],
+  [32, 32],
+  [160, 160],
+  [5760, 5760],
+  [8192, 8202],
+  [8232, 8232],
+  [8233, 8233],
+  [8239, 8239],
+  [8287, 8287],
+  [12288, 12288],
+  [65279, 65279]
+];
 function shorthandRanges(ch) {
-  return ch === "d" ? [[48, 57]] : [[48, 57], [65, 90], [97, 122], [95, 95]];
+  if (ch === "d") return [[48, 57]];
+  if (ch === "s") return SPACE_RANGES;
+  return [[48, 57], [65, 90], [97, 122], [95, 95]];
+}
+function readUnicodeEscape(body, i) {
+  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 };
 }
 function parseClassRanges(body) {
   const ranges = [];
@@ -1384,11 +1407,16 @@ function parseClassRanges(body) {
     const ch = body[i];
     if (ch === void 0) return null;
     if (ch === "\\") {
+      const uni = readUnicodeEscape(body, i);
+      if (uni) {
+        i = uni.next;
+        return { cp: uni.cp };
+      }
       const e = body[i + 1];
       if (e === void 0) return null;
       i += 2;
       if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
-      if (e === "d" || e === "w") return { set: shorthandRanges(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) };
     }
@@ -1416,10 +1444,16 @@ function parseClassRanges(body) {
 function classToRanges(cls) {
   if (cls === "\\d") return shorthandRanges("d");
   if (cls === "\\w") return shorthandRanges("w");
+  if (cls === "\\s") return shorthandRanges("s");
   const body = cls.slice(1, -1);
   if (body.startsWith("^")) return null;
   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})`;
+  return `${cVar} === ${cp}`;
+};
 function literalCodePoints(frag) {
   const out = [];
   let i = 0;
@@ -1466,22 +1500,446 @@ function parseStringShape(source) {
   if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
   return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
 }
+function parseSeqParts(source) {
+  const parts = [];
+  let lit = [];
+  const flush = () => {
+    if (lit.length) {
+      parts.push({ part: "lit", cps: lit, optional: false });
+      lit = [];
+    }
+  };
+  const runFrom = (ranges, negated, q) => {
+    if (q === "+") {
+      parts.push({ part: "run", ranges, negated, min: 1, unbounded: true });
+      return 1;
+    }
+    if (q === "*") {
+      parts.push({ part: "run", ranges, negated, min: 0, unbounded: true });
+      return 1;
+    }
+    if (q === "?") {
+      parts.push({ part: "run", ranges, negated, min: 0, unbounded: false });
+      return 1;
+    }
+    parts.push({ part: "run", ranges, negated, min: 1, unbounded: false });
+    return 0;
+  };
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "[") {
+      let k = i + 1;
+      const neg = source[k] === "^";
+      if (neg) k++;
+      let body = "";
+      while (k < source.length && source[k] !== "]") {
+        if (source[k] === "\\") {
+          body += source[k] + (source[k + 1] ?? "");
+          k += 2;
+        } else {
+          body += source[k];
+          k++;
+        }
+      }
+      if (source[k] !== "]") return null;
+      const ranges = parseClassRanges(body);
+      if (!ranges) return null;
+      flush();
+      i = k + 1;
+      i += runFrom(ranges, neg, source[i]);
+      continue;
+    }
+    if (ch === "\\") {
+      const e = source[i + 1];
+      if (e === "d" || e === "w" || e === "s") {
+        flush();
+        i += 2;
+        i += runFrom(shorthandRanges(e), false, source[i]);
+        continue;
+      }
+      const uni = readUnicodeEscape(source, i);
+      let cp2;
+      if (uni) {
+        cp2 = uni.cp;
+        i = uni.next;
+      } else if (e === void 0) return null;
+      else if (e in CLASS_ESCAPES) {
+        cp2 = CLASS_ESCAPES[e];
+        i += 2;
+      } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      else {
+        cp2 = e.codePointAt(0);
+        i += 2;
+      }
+      if (source[i] === "?") {
+        flush();
+        parts.push({ part: "lit", cps: [cp2], optional: true });
+        i++;
+      } else lit.push(cp2);
+      continue;
+    }
+    if (ch === "(") {
+      if (source[i + 1] !== "?" || source[i + 2] !== ":") return null;
+      let k = i + 3;
+      let depth = 1;
+      while (k < source.length && depth > 0) {
+        const c2 = source[k];
+        if (c2 === "\\") {
+          k += 2;
+          continue;
+        }
+        if (c2 === "[") {
+          let j = k + 1;
+          if (source[j] === "^") j++;
+          while (j < source.length && source[j] !== "]") {
+            if (source[j] === "\\") j += 2;
+            else j++;
+          }
+          if (source[j] !== "]") return null;
+          k = j + 1;
+          continue;
+        }
+        if (c2 === "(") depth++;
+        else if (c2 === ")") depth--;
+        k++;
+      }
+      if (depth !== 0) return null;
+      const body = source.slice(i + 3, k - 1);
+      const inner = parseScanShape(body);
+      if (!inner || !groupInnerSafe(inner)) return null;
+      const q = source[k];
+      if (q === "{") return null;
+      flush();
+      if (q === "+") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 1, unbounded: true });
+        i = k + 1;
+      } else if (q === "*") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 0, unbounded: true });
+        i = k + 1;
+      } else if (q === "?") {
+        parts.push({ part: "group", inner, min: 0, unbounded: false });
+        i = k + 1;
+      } else {
+        parts.push({ part: "group", inner, min: 1, unbounded: false });
+        i = k;
+      }
+      continue;
+    }
+    if (META.has(ch)) return null;
+    const cp = ch.codePointAt(0);
+    i += ch.length;
+    if (source[i] === "?") {
+      flush();
+      parts.push({ part: "lit", cps: [cp], optional: true });
+      i++;
+    } else lit.push(cp);
+  }
+  flush();
+  return parts.length ? parts : null;
+}
+function seqIsUnambiguous(parts) {
+  let hasMandatory = false;
+  for (let k = 0; k < parts.length; k++) {
+    const p = parts[k];
+    const mandatory = p.part === "lit" ? !p.optional : p.min === 1;
+    if (mandatory) hasMandatory = true;
+    const skippableSingle = p.part === "lit" && p.optional || p.part !== "lit" && !p.unbounded && p.min === 0;
+    const isUnboundedRepeat = p.part !== "lit" && p.unbounded;
+    if (skippableSingle || isUnboundedRepeat) {
+      const rest = seqFirstAccept(parts.slice(k + 1));
+      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false;
+    }
+  }
+  return hasMandatory;
+}
+function rangesOverlap(a, b) {
+  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi));
+}
+function rangesSubset(sub, sup) {
+  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2));
+}
+function parseClassOperand(body) {
+  if (body === "\\d" || body === "\\w" || body === "\\s") {
+    return { ranges: shorthandRanges(body[1]), negated: false };
+  }
+  if (body.length >= 2 && body[0] === "[" && body[body.length - 1] === "]") {
+    let inner = body.slice(1, -1);
+    const negated = inner.startsWith("^");
+    if (negated) inner = inner.slice(1);
+    const ranges = parseClassRanges(inner);
+    return ranges ? { ranges, negated } : null;
+  }
+  const cps = literalCodePoints(body);
+  if (cps && cps.length === 1) return { ranges: [[cps[0], cps[0]]], negated: false };
+  return null;
+}
+function classSubset(t, u) {
+  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return false;
+  return rangesSubset(u.ranges, t.ranges);
+}
+function classDisjoint(t, u) {
+  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges);
+  return false;
+}
+function firstSetsDisjoint(a, b) {
+  if (a === "any" || b === "any") return false;
+  return classDisjoint(a, b);
+}
+function trailingBacktrackClass(shape) {
+  if (shape.kind === "chars") return { ranges: shape.ranges, negated: false };
+  if (shape.kind === "ident") return { ranges: shape.tail, negated: false };
+  if (shape.kind === "litFold") return null;
+  if (shape.kind === "seq") {
+    const last = shape.parts[shape.parts.length - 1];
+    if (last.part === "lit") return null;
+    if (last.part === "run") {
+      if (last.unbounded || last.min === 0) return { ranges: last.ranges, negated: last.negated };
+      return null;
+    }
+    const innerWiggle = trailingBacktrackClass(last.inner);
+    if (innerWiggle === "unsupported") return "unsupported";
+    const requiredOnce = !last.unbounded && last.min === 1;
+    if (requiredOnce) return innerWiggle;
+    const dropExposed = shapeFirstAccept(last.inner);
+    if (dropExposed === "any") return "unsupported";
+    if (innerWiggle === null) return dropExposed;
+    const unioned = unionCharSets([innerWiggle, dropExposed]);
+    return unioned === "any" ? "unsupported" : unioned;
+  }
+  if (shape.kind === "alt") {
+    if (!shape.disjoint) return "unsupported";
+    const classes = shape.arms.map(trailingBacktrackClass);
+    if (classes.some((c) => c === "unsupported")) return "unsupported";
+    const concrete = classes.filter((c) => c !== null);
+    if (concrete.length === 0) return null;
+    const unioned = unionCharSets(concrete);
+    return unioned === "any" ? "unsupported" : unioned;
+  }
+  return "unsupported";
+}
+function lookaheadUnambiguous(inner, operand, negative) {
+  const tail = trailingBacktrackClass(inner);
+  if (tail === "unsupported") return false;
+  if (tail === null) return true;
+  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand);
+}
+function stripTrailingLookahead(source) {
+  if (!source.endsWith(")")) return null;
+  for (const negative of [true, false]) {
+    const lead = negative ? "(?!" : "(?=";
+    const idx = source.lastIndexOf(lead);
+    if (idx === -1) continue;
+    const body = source.slice(idx + lead.length, -1);
+    const operand = body.length ? parseClassOperand(body) : null;
+    if (!operand) continue;
+    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative };
+  }
+  return null;
+}
+function unwrapOuterGroup(source) {
+  while (source.startsWith("(?:")) {
+    let depth = 1;
+    let i = 3;
+    let ok = true;
+    while (i < source.length && depth > 0) {
+      const ch = source[i];
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "[") {
+        let j = i + 1;
+        if (source[j] === "^") j++;
+        while (j < source.length && source[j] !== "]") {
+          if (source[j] === "\\") j += 2;
+          else j++;
+        }
+        if (source[j] !== "]") {
+          ok = false;
+          break;
+        }
+        i = j + 1;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+      i++;
+    }
+    if (!ok || depth !== 0 || i !== source.length) break;
+    source = source.slice(3, -1);
+  }
+  return source;
+}
+function splitTopLevelAlternation(source) {
+  const body = unwrapOuterGroup(source);
+  const parts = [];
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (body[j] === "^") j++;
+      while (j < body.length && body[j] !== "]") {
+        if (body[j] === "\\") j += 2;
+        else j++;
+      }
+      if (body[j] !== "]") return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      if (depth < 0) return null;
+      i++;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      parts.push(body.slice(last, i));
+      last = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (depth !== 0) return null;
+  parts.push(body.slice(last));
+  if (parts.length < 2 || parts.some((p) => p.length === 0)) return null;
+  return parts;
+}
+function shapeCanBeEmpty(shape) {
+  if (shape.kind === "chars") return !shape.minOne;
+  if (shape.kind === "lookahead") return shapeCanBeEmpty(shape.inner);
+  if (shape.kind === "alt") return shape.arms.some(shapeCanBeEmpty);
+  return false;
+}
+function unionCharSets(sets) {
+  if (sets.some((s) => s === "any")) return "any";
+  const concrete = sets;
+  if (concrete.length === 1) return concrete[0];
+  if (concrete.some((s) => s.negated)) return "any";
+  return { ranges: concrete.flatMap((s) => s.ranges), negated: false };
+}
+function partFirstAccept(part) {
+  if (part.part === "lit") return { ranges: [[part.cps[0], part.cps[0]]], negated: false };
+  if (part.part === "run") return { ranges: part.ranges, negated: part.negated };
+  return shapeFirstAccept(part.inner);
+}
+function seqFirstAccept(parts) {
+  const sets = [];
+  for (const p of parts) {
+    const mandatory = p.part === "lit" ? !p.optional : p.min === 1;
+    sets.push(partFirstAccept(p));
+    if (mandatory) break;
+  }
+  return unionCharSets(sets);
+}
+function groupInnerSafe(shape) {
+  if (shape.kind === "chars" || shape.kind === "ident" || shape.kind === "seq" || shape.kind === "litFold") return true;
+  if (shape.kind === "lookahead") return groupInnerSafe(shape.inner);
+  if (shape.kind === "alt") return shape.disjoint;
+  return false;
+}
+function shapeFirstAccept(shape) {
+  if (shapeCanBeEmpty(shape)) return "any";
+  switch (shape.kind) {
+    case "chars":
+      return { ranges: shape.ranges, negated: false };
+    case "ident":
+      return { ranges: shape.head, negated: false };
+    case "until":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "delimited":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "string":
+      return { ranges: [[shape.quote, shape.quote]], negated: false };
+    case "litFold": {
+      const cp = shape.open[0];
+      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false };
+      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false };
+      return { ranges: [[cp, cp]], negated: false };
+    }
+    case "seq":
+      return seqFirstAccept(shape.parts);
+    case "lookahead":
+      return shapeFirstAccept(shape.inner);
+    // zero-width — doesn't change first-char acceptance
+    case "alt": {
+      if (!shape.disjoint) return "any";
+      const sets = shape.firsts.filter((f) => f !== null);
+      return sets.length === shape.arms.length ? unionCharSets(sets) : "any";
+    }
+  }
+}
+function allPairsDisjoint(sets) {
+  for (let i = 0; i < sets.length; i++) {
+    const a = sets[i];
+    if (a === "any") return false;
+    for (let j = i + 1; j < sets.length; j++) {
+      const b = sets[j];
+      if (b === "any" || !classDisjoint(a, b)) return false;
+    }
+  }
+  return true;
+}
+function parseAlternation(source) {
+  const parts = splitTopLevelAlternation(source);
+  if (!parts) return null;
+  const arms = [];
+  for (const p of parts) {
+    const arm = parseScanShape(p);
+    if (!arm) return null;
+    arms.push(arm);
+  }
+  const firstSets = arms.map(shapeFirstAccept);
+  const disjoint = allPairsDisjoint(firstSets);
+  return { kind: "alt", arms, disjoint, firsts: firstSets.map((f) => f === "any" ? null : f) };
+}
 function parseScanShape(source) {
+  const alt = parseAlternation(source);
+  if (alt) return alt;
+  const la = stripTrailingLookahead(source);
+  if (la) {
+    const inner = parseScanShapeCore(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 parseScanShapeCore(source);
+}
+function parseScanShapeCore(source) {
   let m = /^\[((?:\\.|[^\]])+)\]([+*])$/.exec(source);
-  if (m) {
-    if (m[1].startsWith("^")) return null;
+  if (m && !m[1].startsWith("^")) {
     const ranges = parseClassRanges(m[1]);
     return ranges ? { kind: "chars", ranges, minOne: m[2] === "+" } : null;
   }
-  m = /^\\([dw])([+*])$/.exec(source);
+  m = /^\\([dws])([+*])$/.exec(source);
   if (m) {
     return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
   }
-  m = /^(\[(?:\\.|[^\]])+\]|\\[dw])(\[(?:\\.|[^\]])+\]|\\[dw])\*$/.exec(source);
+  m = /^(\[(?:\\.|[^\]])+\]|\\[dws])(\[(?:\\.|[^\]])+\]|\\[dws])\*$/.exec(source);
   if (m) {
     const head = classToRanges(m[1]);
     const tail = classToRanges(m[2]);
-    return head && tail ? { kind: "ident", head, tail } : null;
+    if (head && tail) return { kind: "ident", head, tail };
   }
   const str = parseStringShape(source);
   if (str) return str;
@@ -1490,7 +1948,6 @@ function parseScanShape(source) {
     const open = literalCodePoints(m[1]);
     const stop = parseClassRanges(m[2]);
     if (open && stop) return { kind: "until", open, stop };
-    return null;
   }
   if (!source.includes("\\\\")) {
     m = /^(.*?)\((?:\?:)?[\s\S]*\)\*(.*?)$/.exec(source);
@@ -1500,10 +1957,16 @@ function parseScanShape(source) {
       if (open && close) return { kind: "delimited", open, close };
     }
   }
+  const parts = parseSeqParts(source);
+  if (parts && seqIsUnambiguous(parts)) return { kind: "seq", parts };
   return null;
 }
 function scanShapeFromRegex(source, flags) {
-  if (/[imsu]/.test(flags)) return null;
+  if (/[msu]/.test(flags)) return null;
+  if (/i/.test(flags)) {
+    const open = literalCodePoints(source);
+    return open ? { kind: "litFold", open } : null;
+  }
   return parseScanShape(source);
 }
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
@@ -1518,6 +1981,53 @@ function stringHardStop(shape) {
 }
 var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
 function emitShapeMatch(shape, start, mint, ind2, firstChar) {
+  if (shape.kind === "lookahead") {
+    const inner = emitShapeMatch(shape.inner, start, mint, ind2, firstChar);
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const rawIn = classCond(`input.charCodeAt(${inner.end})`, shape.ranges);
+    const charInClass = shape.classNegated ? `!(${rawIn})` : `(${rawIn})`;
+    const hasMatchingChar = `${inner.end} < input.length && ${charInClass}`;
+    const guardFails = shape.negative ? hasMatchingChar : `!(${hasMatchingChar})`;
+    return {
+      setup: [
+        ...inner.setup,
+        `${ind2}let ${okV} = ${inner.ok}`,
+        `${ind2}let ${endV2} = ${inner.end}`,
+        `${ind2}if (${okV} && (${guardFails})) { ${okV} = false; ${endV2} = ${start} }`
+      ],
+      ok: okV,
+      end: endV2
+    };
+  }
+  if (shape.kind === "alt") {
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const lines = [`${ind2}let ${okV} = false`, `${ind2}let ${endV2} = ${start}`];
+    if (shape.disjoint) {
+      const c0 = codeAt(start, firstChar);
+      shape.arms.forEach((arm, k) => {
+        const fs2 = shape.firsts[k];
+        const cond = fs2.negated ? `!(${classCond(c0, fs2.ranges)})` : `(${classCond(c0, fs2.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}: {`);
+      for (const arm of shape.arms) {
+        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+        lines.push(...m.setup);
+        lines.push(`${ind2}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
+      }
+      lines.push(`${ind2}}`);
+    }
+    return { setup: lines, ok: okV, end: endV2 };
+  }
   if (shape.kind === "chars") {
     const cur = mint("_e");
     return {
@@ -1544,6 +2054,82 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
       end: cur
     };
   }
+  if (shape.kind === "seq") {
+    const endV2 = mint("_e");
+    const okV = mint("_ok");
+    const runCond = (p, at) => {
+      const c = classCond(`input.charCodeAt(${at})`, p.ranges);
+      return p.negated ? `!(${c})` : `(${c})`;
+    };
+    const lines = [`${ind2}let ${endV2} = ${start}`, `${ind2}let ${okV} = false`, `${ind2}do {`];
+    let first = true;
+    for (const p of shape.parts) {
+      if (p.part === "lit") {
+        const L = p.cps.length;
+        const cond = litCond(endV2, p.cps, first ? firstChar : void 0);
+        if (p.optional) {
+          lines.push(`${ind2}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
+        } else {
+          lines.push(`${ind2}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
+          lines.push(`${ind2}  ${endV2} += ${L}`);
+        }
+      } else if (p.part === "run" && !p.unbounded) {
+        if (p.min === 1) {
+          lines.push(`${ind2}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
+          lines.push(`${ind2}  ${endV2}++`);
+        } else {
+          lines.push(`${ind2}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        }
+      } else if (p.part === "run") {
+        const s = mint("_s");
+        lines.push(`${ind2}  const ${s} = ${endV2}`);
+        lines.push(`${ind2}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min === 1) lines.push(`${ind2}  if (${endV2} === ${s}) break`);
+      } else {
+        const inner = emitShapeMatch(p.inner, endV2, mint, `${ind2}  `, first ? firstChar : void 0);
+        if (!p.unbounded) {
+          lines.push(...inner.setup);
+          if (p.min === 1) {
+            lines.push(`${ind2}  if (!(${inner.ok})) break`);
+            lines.push(`${ind2}  ${endV2} = ${inner.end}`);
+          } else {
+            lines.push(`${ind2}  if (${inner.ok}) ${endV2} = ${inner.end}`);
+          }
+        } else {
+          const progV = mint("_prog");
+          lines.push(`${ind2}  let ${progV} = false`);
+          lines.push(`${ind2}  while (true) {`);
+          lines.push(...inner.setup);
+          lines.push(`${ind2}    if (!(${inner.ok})) break`);
+          lines.push(`${ind2}    ${endV2} = ${inner.end}`);
+          lines.push(`${ind2}    ${progV} = true`);
+          lines.push(`${ind2}  }`);
+          if (p.min === 1) lines.push(`${ind2}  if (!${progV}) break`);
+        }
+      }
+      first = false;
+    }
+    lines.push(`${ind2}  ${okV} = true`);
+    lines.push(`${ind2}} while (false)`);
+    lines.push(`${ind2}if (!${okV}) ${endV2} = ${start}`);
+    return { setup: lines, ok: okV, end: endV2 };
+  }
+  if (shape.kind === "litFold") {
+    const openLen2 = shape.open.length;
+    const endV2 = mint("_end");
+    const checks = shape.open.map((cp, k) => {
+      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`;
+      return foldEq(cVar, cp);
+    });
+    return {
+      setup: [
+        `${ind2}let ${endV2} = ${start}`,
+        `${ind2}if (${start} + ${openLen2} <= input.length && (${checks.join(" && ")})) ${endV2} = ${start} + ${openLen2}`
+      ],
+      ok: `${endV2} > ${start}`,
+      end: endV2
+    };
+  }
   if (shape.kind === "until") {
     const j2 = mint("_j");
     const openLen2 = shape.open.length;
@@ -1939,7 +2525,7 @@ function hoistExpected(ctx, constArrSource) {
   let name = ctx.expectedMap.get(constArrSource);
   if (name === void 0) {
     name = `_fx${ctx.expectedDecls.length}`;
-    ctx.expectedDecls.push(`const ${name} = Object.freeze(${constArrSource})`);
+    ctx.expectedDecls.push(`const ${name} = ${constArrSource}`);
     ctx.expectedMap.set(constArrSource, name);
   }
   return name;
@@ -2120,10 +2706,10 @@ function ensureTriviaFn(ctx) {
 function ensureTriviaCaptureFn(ctx) {
   return ensureTriviaFn(ctx);
 }
-function firstSetCond(codeVar, fs) {
-  if (fs.kind === "any") return "true";
-  if (fs.kind === "empty") return "false";
-  return fs.ranges.map(
+function firstSetCond(codeVar, fs2) {
+  if (fs2.kind === "any") return "true";
+  if (fs2.kind === "empty") return "false";
+  return fs2.ranges.map(
     (r) => r.lo === r.hi ? `${codeVar} === ${r.lo}` : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`
   ).join(" || ");
 }
@@ -2135,10 +2721,10 @@ function planDisjointDispatch(parsers) {
   const cases = [];
   let total = 0;
   for (const p of parsers) {
-    const fs = p._meta.firstSet;
-    if (fs.kind !== "ranges") return { kind: "if" };
+    const fs2 = p._meta.firstSet;
+    if (fs2.kind !== "ranges") return { kind: "if" };
     const pts = [];
-    for (const r of fs.ranges) {
+    for (const r of fs2.ranges) {
       if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: "if" };
       for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp);
     }
@@ -2261,18 +2847,21 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
       return true;
   }
 }
-function emitFallible(inner, ctx, pos) {
+function emitFallible(inner, ctx, pos, swallow = false) {
   const lbl = v(ctx, "_lbl");
   const okV = `${lbl}ok`;
   const valV = `${lbl}v`;
   const endV = `${lbl}e`;
   const savedLabel = ctx.failLabel;
   const savedIndent = ctx.indent;
+  const savedRecord = ctx.recordFail;
   ctx.failLabel = lbl;
   ctx.indent = savedIndent + 1;
+  if (swallow) ctx.recordFail = false;
   const r = emit(inner, ctx, pos);
   ctx.failLabel = savedLabel;
   ctx.indent = savedIndent;
+  ctx.recordFail = savedRecord;
   const ind0 = ind(ctx);
   const needsRollback = ctx.capturing && mayLeavePartialCapture(inner);
   const mL = needsRollback ? v(ctx, "_fcl") : null;
@@ -2295,6 +2884,7 @@ function emitFallible(inner, ctx, pos) {
   ];
   return { stmts, okVar: okV, valVar: valV, endVar: endV };
 }
+var CHARCODE_CHAIN_MAX = 16;
 function emitLit(def, ctx, pos) {
   const { value, caseInsensitive } = def;
   const len = value.length;
@@ -2317,7 +2907,7 @@ function emitLit(def, ctx, pos) {
       ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
-  } else if (len <= 4) {
+  } else if (len <= CHARCODE_CHAIN_MAX) {
     const checks = Array.from(
       { length: len },
       (_, i) => `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""}) !== ${value.codePointAt(i)}`
@@ -2339,7 +2929,55 @@ function emitLit(def, ctx, pos) {
 function escapeKeywordRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function emitKeywordsFast(def, ctx, pos) {
+  if (def.words.length === 0 || def.words.some((w) => w.length === 0)) return null;
+  if (def.words.some((w) => Array.from(w).length !== w.length)) return null;
+  if (def.caseInsensitive && def.boundary) return null;
+  let boundary = null;
+  if (def.boundary) {
+    let body = def.boundary;
+    const negated = body.startsWith("^");
+    if (negated) body = body.slice(1);
+    const ranges = parseClassRanges(body);
+    if (!ranges) return null;
+    boundary = { ranges, negated };
+  }
+  const mint = (prefix = "_v") => v(ctx, prefix);
+  const lbl = v(ctx, "_kwLbl");
+  const valV = v(ctx, "_kwv");
+  const endV = v(ctx, "_kwe");
+  const bodyInd = ind(ctx) + "  ";
+  const tries = [];
+  for (const w of def.words) {
+    const cps = Array.from(w, (ch) => ch.codePointAt(0));
+    let shape = def.caseInsensitive ? { kind: "litFold", open: cps } : { kind: "seq", parts: [{ part: "lit", cps, optional: false }] };
+    if (boundary) {
+      shape = { kind: "lookahead", inner: shape, ranges: boundary.ranges, classNegated: boundary.negated, negative: true };
+    }
+    const m = emitShapeMatch(shape, pos, mint, bodyInd);
+    tries.push(
+      ...m.setup,
+      // Slice from input rather than reusing the literal word: `caseInsensitive`
+      // must return the text as it actually appeared (e.g. "ABC" for keyword
+      // "abc"), matching what the original `RegExp.exec()[0]` returned.
+      `${bodyInd}if (${m.ok}) { ${valV} = input.slice(${pos}, ${m.end}); ${endV} = ${m.end}; break ${lbl} }`
+    );
+  }
+  const stmts = [
+    `${ind(ctx)}let ${valV} = '', ${endV} = ${pos}`,
+    `${ind(ctx)}${lbl}: {`,
+    ...tries,
+    `${ind(ctx)}}`,
+    // Every word has length >= 1 (checked above), so a real match always
+    // advances past `pos` — `endV === pos` only happens when no candidate matched.
+    ...emitIfFail(ctx, `${endV} === ${pos}`, failBody(ctx, '"keyword"', pos))
+  ];
+  stmts.push(...emitLeafCapture(ctx, valV, pos, endV));
+  return { stmts, valueVar: valV, endVar: endV };
+}
 function emitKeywords(def, ctx, pos) {
+  const fast = emitKeywordsFast(def, ctx, pos);
+  if (fast) return fast;
   const alt = def.words.map(escapeKeywordRe).join("|");
   const boundary = def.boundary ? `(?![${def.boundary}])` : "";
   const flags = def.caseInsensitive ? "iuy" : "uy";
@@ -2470,6 +3108,31 @@ function failsAtStart(p) {
       return false;
   }
 }
+function armStaticExpected(ctx, p) {
+  return hoistExpected(ctx, staticExpectedArr([p]));
+}
+function canMatchEmptyAtStart(p) {
+  const d = p._def;
+  switch (d.tag) {
+    case "regex":
+      return /(?:[*?]|\{0,|\{\d*,)/.test(d.source);
+    case "optional":
+      return true;
+    case "many":
+      return true;
+    case "transform":
+    case "label":
+      return canMatchEmptyAtStart(d.parser);
+    case "literal":
+      return d.value.length === 0;
+    default:
+      return false;
+  }
+}
+function needsFirstSetGuard(p) {
+  const fs2 = p._meta.firstSet;
+  return fs2.kind !== "any" && !canMatchEmptyAtStart(p);
+}
 function emitDisjointArm(p, ctx, pos, valV, endV) {
   if (failsAtStart(p)) {
     const r = emit(p, ctx, pos);
@@ -2611,16 +3274,21 @@ function emitFirstMatch(def, ctx, pos) {
   const resValV = v(ctx, "_crv");
   const resEndV = v(ctx, "_cre");
   const resOkV = v(ctx, "_crok");
+  const codeV = v(ctx, "_chcode");
   const slots = def.parsers.map(() => v(ctx, "_cfx"));
   const ind0 = ind(ctx);
   const stmts = [
     `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,
-    `${ind0}let ${slots.join(", ")}`
+    `${ind0}let ${slots.join(", ")}`,
+    `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`
   ];
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
     const gate = def.gates[i];
     const autoNot = def.autoNot[i];
+    const atStart = failsAtStart(p);
+    const staticFx = armStaticExpected(ctx, p);
+    const fsGuard = needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null;
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
@@ -2635,39 +3303,41 @@ function emitFirstMatch(def, ctx, pos) {
     const markTl = armNeedsRollback ? v(ctx, "_cmtl") : null;
     const markLog = armNeedsRollback ? v(ctx, "_cmlg") : null;
     const rollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog) : "";
+    const failSlot = atStart ? staticFx : "_ctx._fx";
     stmts.push(`${ind0}if (${skipCond}) {`);
-    ctx.indent++;
-    const ind1 = ind(ctx);
+    if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
+    ctx.indent += fsGuard ? 2 : 1;
     if (markLeaves) {
       stmts.push(
-        `${ind1}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
-        `${ind1}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
-        `${ind1}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
-        `${ind1}const ${markLog} = _ctx._triviaLog?.length ?? 0`
+        `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
+        `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
+        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
+        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`
       );
     }
-    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos);
+    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart);
     stmts.push(...armStmts);
-    ctx.indent--;
     if (autoNot && autoNot.length > 0) {
       const anCode = v(ctx, "_anc");
       const rejectCond = autoNot.map(
         (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`
       ).join(" || ");
-      stmts.push(`${ind0}  if (${okVar}) {`);
-      stmts.push(`${ind0}    const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`);
-      stmts.push(`${ind0}    if (!(${rejectCond})) {`);
-      stmts.push(`${ind0}      ${resValV} = ${valVar}`);
-      stmts.push(`${ind0}      ${resEndV} = ${endVar}`);
-      stmts.push(`${ind0}      ${resOkV} = true`);
-      stmts.push(`${ind0}    }`);
-      stmts.push(`${ind0}  }`);
-      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx }`);
-      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`);
+      stmts.push(`${ind(ctx)}if (${okVar}) {`);
+      stmts.push(`${ind(ctx)}  const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`);
+      stmts.push(`${ind(ctx)}  if (!(${rejectCond})) {`);
+      stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`);
+      stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`);
+      stmts.push(`${ind(ctx)}    ${resOkV} = true`);
+      stmts.push(`${ind(ctx)}  }`);
+      stmts.push(`${ind(ctx)}}`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`);
+      if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`);
     } else {
-      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
-      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx${rollback ? `; ${rollback}` : ""} }`);
+      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ""} }`);
     }
+    ctx.indent -= fsGuard ? 2 : 1;
+    if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`);
     stmts.push(`${ind0}}`);
   }
   const concatExpr = `[${slots.map((s) => `...(${s} || [])`).join(", ")}]`;
@@ -2700,7 +3370,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
 function emitLiteralCondition(litVal, pos) {
   const len = litVal.length;
   if (len === 0) return "true";
-  if (len > 4) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`;
+  if (len > CHARCODE_CHAIN_MAX) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`;
   const checks = [`${pos} + ${len} <= input.length`];
   for (let i = 0; i < len; i++) {
     const code = litVal.codePointAt(i);
@@ -2749,7 +3419,7 @@ function emitMany(def, ctx, pos) {
       itemPos = npV;
     }
   }
-  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos);
+  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 }`,
@@ -2763,7 +3433,7 @@ function emitMany(def, ctx, pos) {
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
   const endV = v(ctx, "_opte");
-  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos, true);
   const ind0 = ind(ctx);
   const stmts = [
     ...lblStmts,
@@ -2775,7 +3445,7 @@ function emitOptional(def, ctx, pos) {
 function emitSepBy(_p, def, ctx, pos) {
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
-  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos);
+  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos, true);
   const stmts = [
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`,
@@ -2807,11 +3477,11 @@ function emitSepBy(_p, def, ctx, pos) {
       );
       sepAtPos = spV;
       const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
       stmts.push(
         ...nextStmts,
         // item failed → unwind the separator too, back to the end of the last item
@@ -2824,11 +3494,11 @@ function emitSepBy(_p, def, ctx, pos) {
       const spV = v(ctx, "_sp");
       stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
       sepAtPos = spV;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
       stmts.push(
         ...nextStmts,
         `${ind(ctx)}if (!${nextOk}) break`,
@@ -2845,10 +3515,10 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`
       );
     }
-    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
     stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
     const nextRb = markLv ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; ` : "";
-    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd);
+    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
     stmts.push(
       ...nextStmts,
       `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`,
@@ -2906,7 +3576,7 @@ function emitScanTo(def, ctx, pos) {
   return { stmts, valueVar: valV, endVar: curV };
 }
 function emitNot(def, ctx, pos) {
-  const { stmts, okVar } = emitFallible(def.parser, ctx, pos);
+  const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true);
   const label2 = JSON.stringify(`not(${def.parser._tag})`);
   return {
     stmts: [
@@ -2997,11 +3667,14 @@ function emitLazy(p, def, ctx, pos) {
     }
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
+    const savedRecord = ctx.recordFail;
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
+    ctx.recordFail = true;
     const r = emit(resolved, ctx, "_pos");
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
+    ctx.recordFail = savedRecord;
     pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar);
   }
   const fnName = ctx.namedParsers.get(p);
@@ -3181,11 +3854,14 @@ function emit(p, ctx, pos) {
         ctx.namedParsers.set(innerParser, fnName);
         const savedIndent = ctx.indent;
         const savedFailLabel = ctx.failLabel;
+        const savedRecord = ctx.recordFail;
         ctx.indent = 1;
         ctx.failLabel = "_pfail";
+        ctx.recordFail = true;
         const innerR = emit(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
         ctx.failLabel = savedFailLabel;
+        ctx.recordFail = savedRecord;
         pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar);
       }
       const fn = ctx.namedParsers.get(innerParser);
@@ -3333,6 +4009,7 @@ function compile(combinator, mapFnSources) {
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
     expectedMap: /* @__PURE__ */ new Map(),
+    recordFail: true,
     mapFns: [],
     mapFnSrcs: [],
     buildFns: [],
@@ -3415,6 +4092,7 @@ function compileRuleMap(ruleMap) {
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
     expectedMap: /* @__PURE__ */ new Map(),
+    recordFail: true,
     mapFns: [],
     mapFnSrcs: [],
     buildFns: [],
@@ -3589,11 +4267,11 @@ function balanced(open, close, options = {}) {
   return combi;
 }
 function firstSetClassChars(c) {
-  const fs = c._meta.firstSet;
-  if (fs.kind === "empty") return [];
-  if (fs.kind !== "ranges") return null;
+  const fs2 = c._meta.firstSet;
+  if (fs2.kind === "empty") return [];
+  if (fs2.kind !== "ranges") return null;
   const out = [];
-  for (const { lo, hi } of fs.ranges) {
+  for (const { lo, hi } of fs2.ranges) {
     if (hi - lo > 8) return null;
     for (let cp = lo; cp <= hi; cp++) out.push(String.fromCodePoint(cp));
   }
@@ -3897,7 +4575,117 @@ function evaluateCombinatorArray(node2, scope, code) {
   if (!val.every(isCombinator)) return null;
   return val;
 }
-function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
+function asFragmentFactory(expr) {
+  if (expr.type !== "ArrowFunctionExpression" && expr.type !== "FunctionExpression" && expr.type !== "FunctionDeclaration") return null;
+  const fn = expr;
+  return factoryBodyAndReturn(fn) ? fn : null;
+}
+var unwrapParen = (e) => e && e.type === "ParenthesizedExpression" ? e.expression : e;
+function factoryBodyAndReturn(fn) {
+  const body = fn.body;
+  if (!body) return null;
+  const b = unwrapParen(body);
+  if (b.type === "ObjectExpression") return { statements: [], retObj: b };
+  if (b.type === "BlockStatement") {
+    const statements = [];
+    for (const stmt of b.body) {
+      if (stmt.type === "ReturnStatement") {
+        const a = unwrapParen(stmt.argument);
+        if (!a || a.type !== "ObjectExpression") return null;
+        return { statements, retObj: a };
+      }
+      if (stmt.type === "VariableDeclaration") statements.push(stmt);
+      else return null;
+    }
+  }
+  return null;
+}
+function spreadFactoryCall(spread, resolve) {
+  const call = spread.argument;
+  if (!call || call.type !== "CallExpression") return null;
+  if (!call.callee || call.callee.type !== "Identifier" || !call.callee.name) return null;
+  const resolved = resolve(call.callee.name);
+  return resolved ? { fn: resolved.fn, args: call.arguments ?? [], code: resolved.code } : null;
+}
+function factoryCallScope(fn, args, outer) {
+  const s = new Map(outer);
+  const params = fn.params ?? [];
+  for (let i = 0; i < params.length; i++) {
+    const pn = params[i];
+    if (!pn || pn.type !== "Identifier" || !pn.name) continue;
+    const arg = args[i];
+    if (arg && arg.type === "Identifier" && arg.name && outer.has(arg.name)) {
+      s.set(pn.name, outer.get(arg.name));
+    }
+  }
+  return s;
+}
+function propKey(prop) {
+  if (prop.type !== "Property" || prop.computed || !prop.key) return null;
+  if (prop.key.type === "Identifier") return prop.key.name ?? null;
+  if (prop.key.type === "Literal") return String(prop.key.value);
+  return null;
+}
+function collectRuleKeys(retObj, resolve, seen) {
+  const out = [];
+  for (const prop of retObj.properties) {
+    if (prop.type === "SpreadElement") {
+      const sf = spreadFactoryCall(prop, resolve);
+      if (!sf || seen.has(sf.fn)) return null;
+      const br = factoryBodyAndReturn(sf.fn);
+      if (!br) return null;
+      const nested = collectRuleKeys(br.retObj, resolve, new Set(seen).add(sf.fn));
+      if (!nested) return null;
+      out.push(...nested);
+      continue;
+    }
+    const key = propKey(prop);
+    if (!key) return null;
+    out.push(key);
+  }
+  return out;
+}
+function flattenRuleEntries(retObj, scope, code, resolve, seen) {
+  const out = [];
+  for (const prop of retObj.properties) {
+    if (prop.type === "SpreadElement") {
+      const sf = spreadFactoryCall(prop, resolve);
+      if (!sf || seen.has(sf.fn)) return null;
+      const br = factoryBodyAndReturn(sf.fn);
+      if (!br) return null;
+      const fragScope = factoryCallScope(sf.fn, sf.args, scope);
+      if (!evalBodyStatements(br.statements, fragScope, sf.code)) return null;
+      const nested = flattenRuleEntries(br.retObj, fragScope, sf.code, resolve, new Set(seen).add(sf.fn));
+      if (!nested) return null;
+      out.push(...nested);
+      continue;
+    }
+    const key = propKey(prop);
+    if (!key) return null;
+    out.push({ key, value: prop.value, scope, code });
+  }
+  return out;
+}
+function evalBodyStatements(statements, scope, code) {
+  const bodyMfs = [];
+  for (const stmt of statements) {
+    for (const d of stmt.declarations) {
+      const decl = d;
+      if (!decl.init) return false;
+      const id = decl.id;
+      if (id.type !== "Identifier" && id.type !== "BindingIdentifier") return false;
+      const name = id.name;
+      const before = bodyMfs.length;
+      const val = anyValue(decl.init, scope, code, bodyMfs);
+      if (val === null) return false;
+      const thisDeclMfSrcs = bodyMfs.slice(before);
+      if (isCombinator(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      else scope.set(name, val);
+    }
+  }
+  return true;
+}
+function evaluateParserFactory(factoryNode, scope, code, mapFnSources, resolveFactory = () => null) {
   if (factoryNode.type !== "ArrowFunctionExpression" && factoryNode.type !== "FunctionDeclaration" && factoryNode.type !== "FunctionExpression") return null;
   const factory = factoryNode;
   const params = factory.params;
@@ -3929,40 +4717,21 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   if (!returnExpr) return null;
   const retObj = returnExpr.type === "ParenthesizedExpression" ? returnExpr.expression : returnExpr;
   if (retObj.type !== "ObjectExpression") return null;
+  const keys = collectRuleKeys(retObj, resolveFactory, /* @__PURE__ */ new Set());
+  if (!keys) return null;
   const ruleRefs = /* @__PURE__ */ new Map();
-  for (const prop of retObj.properties) {
-    if (prop.type !== "Property") return null;
-    if (prop.computed) return null;
-    const p = prop;
-    const key = p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? String(p.key.value) : null;
-    if (!key) return null;
-    ruleRefs.set(key, ref());
+  for (const key of keys) {
+    if (!ruleRefs.has(key)) ruleRefs.set(key, ref());
   }
   const localScope = new Map(scope);
   localScope.set(proxyName, Object.fromEntries(ruleRefs));
-  const bodyMfs = [];
-  for (const stmt of statements) {
-    for (const d of stmt.declarations) {
-      const decl = d;
-      if (!decl.init) return null;
-      const id = decl.id;
-      if (id.type !== "Identifier" && id.type !== "BindingIdentifier") return null;
-      const name = id.name;
-      const before = bodyMfs.length;
-      const val = anyValue(decl.init, localScope, code, bodyMfs);
-      if (val === null) return null;
-      const thisDeclMfSrcs = bodyMfs.slice(before);
-      if (isCombinator(val)) {
-        localScope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
-      } else {
-        localScope.set(name, val);
-      }
-    }
-  }
-  for (const prop of retObj.properties) {
-    const p = prop;
-    const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
-    const val = anyValue(p.value, localScope, code, mapFnSources);
+  if (!evalBodyStatements(statements, localScope, code)) return null;
+  const entries = flattenRuleEntries(retObj, localScope, code, resolveFactory, /* @__PURE__ */ new Set());
+  if (!entries) return null;
+  const finalByKey = /* @__PURE__ */ new Map();
+  for (const e of entries) finalByKey.set(e.key, e);
+  for (const [key, e] of finalByKey) {
+    const val = anyValue(e.value, e.scope, e.code, mapFnSources);
     if (!isCombinator(val)) return null;
     ruleRefs.get(key).define(val);
   }
@@ -4020,6 +4789,40 @@ function referencesAny(node2, names, scope) {
 
 // src/plugin/index.ts
 var PARSEMAN_MODULE = "parseman";
+var _fragmentResolver = null;
+function getFragmentResolver() {
+  return _fragmentResolver ??= new import_oxc_resolver.ResolverFactory({
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    // TS/NodeNext style: a `./x.js` import may point at `./x.ts` source.
+    extensionAlias: {
+      ".js": [".ts", ".tsx", ".js", ".jsx"],
+      ".mjs": [".mts", ".mjs"],
+      ".cjs": [".cts", ".cjs"]
+    },
+    conditionNames: ["source", "development", "import", "require", "default"],
+    mainFields: ["source", "module", "main"]
+  });
+}
+var _moduleParseCache = /* @__PURE__ */ new Map();
+function parseModuleCached(filePath) {
+  let mtimeMs;
+  try {
+    mtimeMs = fs.statSync(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = _moduleParseCache.get(filePath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.parsed;
+  let parsed = null;
+  try {
+    const src = fs.readFileSync(filePath, "utf8");
+    const r = (0, import_oxc_parser.parseSync)(filePath, src);
+    if (r.errors.length === 0) parsed = { body: r.program.body, src };
+  } catch {
+  }
+  _moduleParseCache.set(filePath, { mtimeMs, parsed });
+  return parsed;
+}
 var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
   name: "parseman",
   // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
@@ -4055,15 +4858,23 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const body = result.program.body;
   const macroImports = [];
   const allNames = /* @__PURE__ */ new Set();
+  const importBindings = /* @__PURE__ */ new Map();
   for (const stmt of body) {
     if (stmt.type !== "ImportDeclaration") continue;
     const s = stmt;
-    if (!moduleAliases.has(s.source.value)) continue;
-    const isMacro = s.attributes.some((a) => {
+    const isMacro = moduleAliases.has(s.source.value) && s.attributes.some((a) => {
       const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
       return key === "type" && a.value.value === "macro";
     });
-    if (!isMacro) continue;
+    if (!isMacro) {
+      for (const spec of s.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          const imported = spec.imported.name ?? spec.local.name;
+          importBindings.set(spec.local.name, { source: s.source.value, imported });
+        }
+      }
+      continue;
+    }
     const names = /* @__PURE__ */ new Set();
     for (const spec of s.specifiers) {
       if (spec.type === "ImportSpecifier") names.add(spec.local.name);
@@ -4073,6 +4884,63 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   }
   if (macroImports.length === 0) return null;
   const scope = /* @__PURE__ */ new Map();
+  const factories = /* @__PURE__ */ new Map();
+  const resolver = getFragmentResolver();
+  const importedFactoryCache = /* @__PURE__ */ new Map();
+  const OUTPUT_DIR = /([\\/])(dist|lib|build|out|output|compiled|cjs|esm|es)([\\/])/;
+  const resolveSourcePath = (spec) => {
+    let resolved = null;
+    try {
+      resolved = resolver.resolveFileSync(id, spec).path ?? null;
+    } catch {
+    }
+    if (!resolved) return null;
+    if (OUTPUT_DIR.test(resolved)) {
+      const srcCandidate = resolved.replace(OUTPUT_DIR, "$1src$3").replace(/\.(c|m)?js$/, ".ts");
+      try {
+        if (fs.statSync(srcCandidate).isFile()) return srcCandidate;
+      } catch {
+      }
+    }
+    return resolved;
+  };
+  const resolveImportedFactory = (name) => {
+    if (importedFactoryCache.has(name)) return importedFactoryCache.get(name);
+    let result2 = null;
+    const binding = importBindings.get(name);
+    if (binding) {
+      const filePath = resolveSourcePath(binding.source);
+      const mod = filePath ? parseModuleCached(filePath) : null;
+      if (mod) {
+        for (const st of mod.body) {
+          if (st.type !== "ExportNamedDeclaration" || !st.declaration) continue;
+          const decl = st.declaration;
+          if (decl.type === "VariableDeclaration") {
+            for (const d of decl.declarations ?? []) {
+              if (d.id?.type === "Identifier" && d.id.name === binding.imported && d.init) {
+                const fac = asFragmentFactory(d.init);
+                if (fac) {
+                  result2 = { fn: fac, code: mod.src };
+                  break;
+                }
+              }
+            }
+          } else if (decl.type === "FunctionDeclaration" && decl.id?.type === "Identifier" && decl.id.name === binding.imported) {
+            const fac = asFragmentFactory(decl);
+            if (fac) result2 = { fn: fac, code: mod.src };
+          }
+          if (result2) break;
+        }
+      }
+    }
+    importedFactoryCache.set(name, result2);
+    return result2;
+  };
+  const resolveFactory = (n) => {
+    const local = factories.get(n);
+    if (local) return { fn: local, code };
+    return resolveImportedFactory(n);
+  };
   const replacements = [];
   const warnings = [];
   let anyUnresolved = false;
@@ -4093,7 +4961,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       warn(init.start, `${label2}: rules() needs a factory argument`);
       return null;
     }
-    const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
+    const ruleMap = evaluateParserFactory(factoryArg, scope, code, [], resolveFactory);
     if (!ruleMap) {
       warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
@@ -4191,6 +5059,11 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           });
           continue;
         }
+        const frag = asFragmentFactory(init);
+        if (frag) {
+          factories.set(varName, frag);
+          continue;
+        }
         const mapFnSources = [];
         const parser2 = evaluateExpr(init, scope, code, mapFnSources);
         if (parser2 === null) {