parseman 0.8.0 → 0.10.0

package/dist/plugin/index.cjs

@@ -1134,24 +1134,70 @@ function not(combinator) {
   };
 }
 
+// src/compiler/build-arity.ts
+var PARAM_LIST_RE = (
+  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`
+  /^(?:function\b[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|([A-Za-z_$][\w$]*)\s*=>)/
+);
+var CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\w$]*\s*\??\s*(?::[^,=]+)?$/;
+function confirmedBuildArity(src) {
+  const s = src.trim();
+  const m = PARAM_LIST_RE.exec(s);
+  if (!m) return null;
+  if (m[3] !== void 0) return 1;
+  const inner = (m[1] ?? m[2] ?? "").trim();
+  if (inner === "") return 0;
+  const parts = inner.split(",");
+  for (const part of parts) {
+    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null;
+  }
+  if (/\barguments\b/.test(s)) return null;
+  return parts.length;
+}
+function buildReadsTrivia(def) {
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 4;
+}
+function buildReadsState(def) {
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 5;
+}
+
 // src/combinators/node.ts
-function node(type, combinator, build) {
+function collapseChild(child) {
+  return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
+}
+function node(type, combinator, build, opts) {
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
+  const collapse = opts?.collapse === true;
+  const def = collapse ? { tag: "node", type, parser: combinator, build, collapse: true } : { tag: "node", type, parser: combinator, build };
+  const capturesTrivia = buildReadsTrivia(def);
+  const clonesState = buildReadsState(def);
   return {
     _tag: "node",
     _meta: meta,
-    _def: { tag: "node", type, parser: combinator, build },
+    _def: def,
     parse(input, pos, ctx) {
       const saved = beginCstNodeCapture(ctx);
+      if (!capturesTrivia) ctx.captureTrivia = false;
       const r = combinator.parse(input, pos, ctx);
       const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const state = ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = build(children, rawChildren, r.span, triviaLog, state);
+      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build(
+        children,
+        rawChildren,
+        r.span,
+        triviaLog,
+        clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0
+      );
       const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
       const rawEntry = isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
@@ -1269,14 +1315,140 @@ function noTrivia(root) {
   return parser({ trivia: null }, root);
 }
 
+// src/compiler/scannable-run.ts
+var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
+var META = new Set("()[]{}*+?|^$.".split(""));
+function parseClassRanges(body) {
+  const ranges = [];
+  let i = 0;
+  const readCp = () => {
+    const ch = body[i];
+    if (ch === void 0) return null;
+    if (ch === "\\") {
+      const e = body[i + 1];
+      if (e === void 0) return null;
+      i += 2;
+      return e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0);
+    }
+    i += ch.length;
+    return ch.codePointAt(0);
+  };
+  while (i < body.length) {
+    const lo = readCp();
+    if (lo === null) return null;
+    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
+      i += 1;
+      const hi = readCp();
+      if (hi === null) return null;
+      ranges.push([lo, hi]);
+    } else {
+      ranges.push([lo, lo]);
+    }
+  }
+  return ranges.length ? ranges : null;
+}
+function literalCodePoints(frag) {
+  const out = [];
+  let i = 0;
+  while (i < frag.length) {
+    const ch = frag[i];
+    if (ch === "\\") {
+      const e = frag[i + 1];
+      if (e === void 0) return null;
+      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
+      i += 2;
+      continue;
+    }
+    if (META.has(ch)) return null;
+    out.push(ch.codePointAt(0));
+    i += 1;
+  }
+  return out.length ? out : null;
+}
+function parseScanShape(source) {
+  let m = /^\[((?:\\.|[^\]])+)\]([+*])$/.exec(source);
+  if (m) {
+    if (m[1].startsWith("^")) return null;
+    const ranges = parseClassRanges(m[1]);
+    return ranges ? { kind: "chars", ranges } : null;
+  }
+  m = /^(.*?)\[\^((?:\\.|[^\]])+)\]\*$/.exec(source);
+  if (m) {
+    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);
+    if (m && m[1] && m[2]) {
+      const open = literalCodePoints(m[1]);
+      const close = literalCodePoints(m[2]);
+      if (open && close) return { kind: "delimited", open, close };
+    }
+  }
+  return 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}`
+).join(" && ");
+function advanceExpr(shape) {
+  if (shape.kind === "chars") {
+    return {
+      setup: [
+        `      _e++`,
+        `      while (_e < input.length) { const c2 = input.charCodeAt(_e); if (${classCond("c2", shape.ranges)}) _e++; else break }`
+      ],
+      endVar: "_e"
+    };
+  }
+  if (shape.kind === "until") {
+    return {
+      setup: [
+        `      let j = _e + ${shape.open.length}`,
+        `      while (j < input.length && !(${classCond("input.charCodeAt(j)", shape.stop)})) j++`
+      ],
+      endVar: "j"
+    };
+  }
+  const n = shape.close.length;
+  return {
+    setup: [
+      `      let j = _e + ${shape.open.length}`,
+      `      while (j + ${n - 1} < input.length && !(${litCond("j", shape.close)})) j++`
+    ],
+    endVar: n === 1 ? "(j + 1 <= input.length ? j + 1 : input.length)" : `(j + ${n} <= input.length ? j + ${n} : input.length)`
+  };
+}
+function guardLine(shape) {
+  const cond = shape.kind === "chars" ? classCond("c", shape.ranges) : litCond("_e", shape.open, "c");
+  return `    if (${cond}) {`;
+}
+function scanBranch(shape) {
+  if (shape.kind === "chars") {
+    return `    if (${classCond("c", shape.ranges)}) { _e++; continue }`;
+  }
+  const { setup, endVar } = advanceExpr(shape);
+  return [guardLine(shape), ...setup, `      _e = ${endVar}`, `      continue`, `    }`].join("\n");
+}
+function captureChunk(startVar, kindIndex) {
+  return [
+    `      if (_cap) {`,
+    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(${startVar}, _e, ${kindIndex})`,
+    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(${startVar}, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,
+    `      }`
+  ];
+}
+function scanBranchLabeled(shape, kindIndex) {
+  const { setup, endVar } = advanceExpr(shape);
+  const lines = [guardLine(shape), `      const _cs = _e`, ...setup];
+  if (endVar !== "_e") lines.push(`      _e = ${endVar}`);
+  lines.push(...captureChunk("_cs", kindIndex), `      continue`, `    }`);
+  return lines.join("\n");
+}
+
 // src/compiler/trivia-fast-path.ts
-var BLOCK_COMMENT = String.raw`\/\*(?:[^*]|\*(?!\/))*\*\/`;
-var WS_CLASS_SOURCES = /* @__PURE__ */ new Set([
-  String.raw`[ \t\n\r\f]+`,
-  String.raw`[ \t\n]+`,
-  String.raw`[ \t]+`,
-  String.raw`[\t\n\f\r ]+`
-]);
 function unwrapTrivia2(p) {
   let cur = p;
   while (cur._def.tag === "trivia") cur = cur._def.parser;
@@ -1292,36 +1464,30 @@ function choiceArms(p) {
   if (p._def.tag === "choice") return p._def.parsers;
   return null;
 }
-function isWsClassSource(source) {
-  return WS_CLASS_SOURCES.has(source);
-}
-function isBlockCommentSource(source) {
-  return source === BLOCK_COMMENT;
+function armShape(arm) {
+  const src = getCoreRegexDef(arm)?.source;
+  return src ? parseScanShape(src) : null;
 }
 function analyzeTriviaFastPath(trivia2) {
   const core = unwrapTrivia2(trivia2);
-  const direct = getCoreRegexDef(core)?.source;
-  if (direct) {
-    if (isWsClassSource(direct)) return "wsOnly";
-    return null;
+  const directSrc = getCoreRegexDef(core)?.source;
+  if (directSrc) {
+    const shape = parseScanShape(directSrc);
+    return shape && shape.kind === "chars" ? [shape] : null;
   }
   const inner = oneOrMoreInner(core);
   if (!inner) return null;
-  const innerSrc = getCoreRegexDef(inner)?.source;
-  if (innerSrc && isWsClassSource(innerSrc)) return "wsOnly";
+  const innerShape = armShape(inner);
+  if (innerShape) return innerShape.kind === "chars" ? [innerShape] : null;
   const arms = choiceArms(inner);
-  if (!arms || arms.length !== 2) return null;
-  let hasWs = false;
-  let hasComment = false;
+  if (!arms || arms.length < 2) return null;
+  const shapes = [];
   for (const arm of arms) {
-    const src = getCoreRegexDef(arm)?.source;
-    if (!src) return null;
-    if (isWsClassSource(src)) hasWs = true;
-    else if (isBlockCommentSource(src)) hasComment = true;
-    else return null;
+    const shape = armShape(arm);
+    if (!shape) return null;
+    shapes.push(shape);
   }
-  if (hasWs && hasComment) return "wsComments";
-  return null;
+  return shapes;
 }
 var CAP_RECORD = [
   `  if (_cap && _e > _pos) {`,
@@ -1329,80 +1495,49 @@ var CAP_RECORD = [
   `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
   `  }`
 ].join("\n");
-var WS_ONLY_LOOP = [
-  `  while (_e < input.length) {`,
-  `    const c = input.charCodeAt(_e)`,
-  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,
-  `    break`,
-  `  }`
-].join("\n");
-var WS_COMMENTS_LOOP = [
-  `  while (_e < input.length) {`,
-  `    const c = input.charCodeAt(_e)`,
-  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,
-  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,
-  `      let j = _e + 2`,
-  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,
-  `      _e = j + 2 <= input.length ? j + 2 : input.length`,
-  `      continue`,
-  `    }`,
-  `    break`,
-  `  }`
-].join("\n");
-var CAP_CHUNK = (wsKind, commentKind) => [
-  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {`,
-  `      const _cs = _e`,
-  `      _e++`,
-  `      while (_e < input.length) {`,
-  `        const c2 = input.charCodeAt(_e)`,
-  `        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) _e++`,
-  `        else break`,
-  `      }`,
-  `      if (_cap) {`,
-  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${wsKind})`,
-  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${wsKind})`,
-  `      }`,
-  `      continue`,
-  `    }`,
-  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,
-  `      const _cs = _e`,
-  `      let j = _e + 2`,
-  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,
-  `      _e = j + 2 <= input.length ? j + 2 : input.length`,
-  `      if (_cap) {`,
-  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${commentKind})`,
-  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${commentKind})`,
-  `      }`,
-  `      continue`,
-  `    }`
-].join("\n");
-var WS_COMMENTS_LOOP_LABELED = (wsKind, commentKind) => [
-  `  while (_e < input.length) {`,
-  `    const c = input.charCodeAt(_e)`,
-  CAP_CHUNK(wsKind, commentKind),
-  `    break`,
-  `  }`
-].join("\n");
-function buildFastTriviaFnDecl(fnName, kind, kindIndices) {
-  const loop = kind === "wsComments" && kindIndices ? WS_COMMENTS_LOOP_LABELED(kindIndices.ws, kindIndices.comment) : kind === "wsComments" ? WS_COMMENTS_LOOP : WS_ONLY_LOOP;
-  const cap = kindIndices ? "" : CAP_RECORD;
-  const lines = [
+function composeFastLoop(shapes) {
+  return [
+    `  while (_e < input.length) {`,
+    `    const c = input.charCodeAt(_e)`,
+    ...shapes.map(scanBranch),
+    `    break`,
+    `  }`
+  ].join("\n");
+}
+function buildFastTriviaFnDecl(fnName, shapes) {
+  return [
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
-    loop
-  ];
-  if (cap) lines.push(cap);
-  lines.push(`  return _e`, `}`);
-  return lines.join("\n");
+    composeFastLoop(shapes),
+    CAP_RECORD,
+    `  return _e`,
+    `}`
+  ].join("\n");
 }
-function regexArmIndex(spec, isComment) {
+function analyzeLabeledScannableRun(trivia2) {
+  const spec = analyzeLabeledTrivia(trivia2);
+  if (!spec) return null;
+  const out = [];
   for (const arm of spec.arms) {
     const src = getCoreRegexDef(arm.parser)?.source;
-    if (!src) return null;
-    const comment = src.includes("\\*") || src.startsWith("\\/\\/");
-    if (comment === isComment) return arm.kindIndex;
+    const shape = src ? parseScanShape(src) : null;
+    if (!shape) return null;
+    out.push({ shape, kindIndex: arm.kindIndex });
   }
-  return null;
+  return out;
+}
+function buildLabeledScannableTriviaFnDecl(fnName, arms) {
+  return [
+    `function ${fnName}(input, _pos, _ctx, _cap) {`,
+    `  let _e = _pos`,
+    `  while (_e < input.length) {`,
+    `    const c = input.charCodeAt(_e)`,
+    ...arms.map((a) => scanBranchLabeled(a.shape, a.kindIndex)),
+    `    break`,
+    `  }`,
+    `  return _e`,
+    `}`
+  ].join("\n");
 }
 function buildLabeledRegexTriviaFnDecl(fnName, spec, reNames) {
   const tryArms = spec.arms.map((arm, i) => {
@@ -1435,14 +1570,6 @@ function buildLabeledRegexTriviaFnDecl(fnName, spec, reNames) {
     `}`
   ].join("\n");
 }
-function labeledTriviaKindIndices(trivia2) {
-  const spec = analyzeLabeledTrivia(trivia2);
-  if (!spec || spec.arms.length !== 2) return null;
-  const ws = regexArmIndex(spec, false);
-  const comment = regexArmIndex(spec, true);
-  if (ws === null || comment === null) return null;
-  return { ws, comment };
-}
 function labeledTriviaRegexArms(trivia2) {
   const spec = analyzeLabeledTrivia(trivia2);
   if (!spec) return null;
@@ -1690,14 +1817,19 @@ function ensureTriviaFn(ctx) {
   const fnName = `_tf${ctx.triviaFnNames.size}`;
   ctx.triviaFnNames.set(trivia2, fnName);
   ctx.triviaCaptureNames.set(trivia2, fnName);
-  const fastKind = analyzeTriviaFastPath(trivia2);
-  const kindIndices = labeledTriviaKindIndices(trivia2);
-  if (fastKind) {
-    ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastKind, kindIndices ?? void 0));
-    return fnName;
-  }
   const labeledSpec = analyzeLabeledTrivia(trivia2);
-  if (labeledSpec) {
+  if (!labeledSpec) {
+    const fastShapes = analyzeTriviaFastPath(trivia2);
+    if (fastShapes) {
+      ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastShapes));
+      return fnName;
+    }
+  } else {
+    const labeledShapes = analyzeLabeledScannableRun(trivia2);
+    if (labeledShapes) {
+      ctx.namedFnDecls.push(buildLabeledScannableTriviaFnDecl(fnName, labeledShapes));
+      return fnName;
+    }
     const regexSpec = labeledTriviaRegexArms(trivia2);
     if (regexSpec) {
       const reNames = [];
@@ -2135,11 +2267,11 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     const p = def.parsers[idx];
     const litVal = getCoreLiteralValue(p);
     const litLen = litVal.length;
-    const litCond = emitLiteralCondition(litVal, pos);
+    const litCond2 = emitLiteralCondition(litVal, pos);
     const kw = first ? "if" : "else if";
     first = false;
     const litEnd = `${pos} + ${litLen}`;
-    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`);
+    stmts.push(`${ind(ctx)}${kw} (${litCond2}) {`);
     ctx.indent++;
     const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx);
     stmts.push(
@@ -2468,25 +2600,34 @@ function emitNode(def, ctx, pos) {
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
+  const capturesTrivia = mkType !== null || buildReadsTrivia(def);
+  const clonesState = buildReadsState(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
-  const tlV = v(ctx, "_tl");
+  const tlV = capturesTrivia ? 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";
   const stmts = [
-    `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`,
+    allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
-    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${tlV}`
+    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${innerTl}`
   ];
   const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos);
   stmts.push(...innerStmts);
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, failBody(ctx, '"node"', pos)));
-  const stV = v(ctx, "_nst");
-  stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+  let stV = "undefined";
+  if (clonesState) {
+    stV = v(ctx, "_nst");
+    stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+  }
   const ndV = v(ctx, "_nd");
   const ndExpr = mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `_build[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
+  const finalExpr = def.collapse ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})` : ndExpr;
   stmts.push(
-    `${i}const ${ndV} = ${ndExpr}`,
+    `${i}const ${ndV} = ${finalExpr}`,
     `${i}if (${sc}) ${sc}.push(${ndV})`,
     `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`
   );
@@ -2507,6 +2648,16 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   return { stmts, valueVar: vv, endVar: ev };
 }
 function emitLazy(p, def, ctx, pos) {
+  const usage = ctx.lazyUsage;
+  if (usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
+    let resolved;
+    try {
+      resolved = def.thunk();
+    } catch {
+      return emitRuntimeFallback(p, ctx, pos);
+    }
+    return emit(resolved, ctx, pos);
+  }
   if (!ctx.namedParsers.has(p)) {
     const fnName2 = `_pf${ctx.namedParsers.size}`;
     ctx.namedParsers.set(p, fnName2);
@@ -2771,6 +2922,80 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "many":
+    case "optional":
+    case "transform":
+    case "trivia":
+    case "label":
+    case "grammar":
+    case "not":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return [def.parser];
+    // emitMany's oneOrMore branch and emitSepBy both codegen `def.parser` TWICE
+    // (a mandatory first match, then again inside the repeat loop) — two real
+    // emit() call sites, so the usage analysis must see two edges here or it
+    // undercounts a single-use `parser` ref as inline-safe when it's actually
+    // referenced from two positions within this one compiled function.
+    case "oneOrMore":
+      return [def.parser, def.parser];
+    case "sepBy":
+      return [def.parser, def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "recover":
+      return [def.parser, def.sentinel];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "unknown":
+      return [];
+  }
+}
+function analyzeLazyUsage(root) {
+  return analyzeLazyUsageMulti([root]);
+}
+function analyzeLazyUsageMulti(roots) {
+  const counts = /* @__PURE__ */ new Map();
+  const recursive = /* @__PURE__ */ new Set();
+  const descended = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  function walk(p) {
+    const def = p._def;
+    if (def.tag === "lazy") {
+      counts.set(p, (counts.get(p) ?? 0) + 1);
+      if (active.has(p)) {
+        recursive.add(p);
+        return;
+      }
+      if (descended.has(p)) return;
+      descended.add(p);
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        return;
+      }
+      active.add(p);
+      walk(resolved);
+      active.delete(p);
+      return;
+    }
+    for (const child of childrenOf(def)) walk(child);
+  }
+  for (const root of roots) walk(root);
+  return { counts, recursive };
+}
 function compile(combinator, mapFnSources) {
   const ctx = {
     vars: 0,
@@ -2787,13 +3012,16 @@ function compile(combinator, mapFnSources) {
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
     namedFnDecls: [],
-    capturing: hasNodeDef(combinator)
+    capturing: hasNodeDef(combinator),
+    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 source = [
+    ...emptyTlDecls,
     ...ctx.regexDecls,
     "",
     ...namedPrelude,
@@ -2805,6 +3033,7 @@ function compile(combinator, mapFnSources) {
     `}`
   ].join("\n");
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
+    ...emptyTlDecls,
     ...ctx.regexDecls,
     collatorDecl,
     ...namedPrelude,
@@ -2845,6 +3074,67 @@ function compile(combinator, mapFnSources) {
     }
   };
 }
+function compileRuleMap(ruleMap) {
+  const ctx = {
+    vars: 0,
+    indent: 1,
+    regexDecls: [],
+    regexMap: /* @__PURE__ */ new Map(),
+    mapFns: [],
+    mapFnSrcs: [],
+    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))
+  };
+  const perEntry = ruleMap.map(([key, rule]) => ({ key, r: emit(rule, ctx, "_pos") }));
+  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
+` : "";
+  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : void 0;
+  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s) => s !== null);
+  const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
+  const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== void 0;
+  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
+  if (!canInline) return null;
+  const mfDecl = derivedSrcs?.length ? `  const _mf = [${derivedSrcs.join(", ")}]` : "";
+  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
+  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
+  const hoistedDecls = [
+    ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
+    ...ctx.regexDecls.map((d) => `  ${d}`),
+    collatorDecl ? `  ${collatorDecl.trim()}` : "",
+    mfDecl,
+    buildDecl,
+    ...namedPrelude.map((l) => `  ${l}`),
+    ...ctx.namedFnDecls.flatMap((decl, i) => {
+      const lines = decl.split("\n").map((l) => `  ${l}`);
+      return i > 0 ? ["", ...lines] : lines;
+    })
+  ].filter(Boolean);
+  const entryFnText = (r) => [
+    `function(input, _pos, _ctx) {`,
+    `  let pos = _pos`,
+    ...r.stmts,
+    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+    `}`
+  ].join("\n");
+  const objBody = perEntry.map(({ key, r }) => `    ${JSON.stringify(key)}: ${entryFnText(r).split("\n").join("\n    ")}`).join(",\n");
+  const replacement = [
+    `/* @__PURE__ */ (() => {`,
+    ...hoistedDecls,
+    `  return {`,
+    objBody,
+    `  }`,
+    `})()`
+  ].join("\n");
+  return { keys: perEntry.map((e) => e.key), replacement };
+}
 function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
@@ -2858,10 +3148,12 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   ].join("\n");
   const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl;
+  const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
+    emptyTlDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
@@ -3062,6 +3354,20 @@ function scopeGet(scope, name, mfs) {
   if (isCombinator(entry)) return entry;
   return null;
 }
+function staticCollapseOption(expr) {
+  if (expr.type !== "ObjectExpression") return false;
+  for (const prop of expr.properties) {
+    const p = prop;
+    if (p.computed) continue;
+    const key = p.key;
+    const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
+    if (name === "collapse") {
+      const val = p.value;
+      return (val.type === "Literal" || val.type === "BooleanLiteral") && val.value === true;
+    }
+  }
+  return false;
+}
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
   if (node2.type !== "CallExpression") return null;
@@ -3110,15 +3416,16 @@ function exprToCombi(node2, scope, code, mfs) {
     }
   }
   if (callee.name === "node" && code !== void 0) {
-    const [typeArg, parserArg, buildArg] = node2.arguments;
+    const [typeArg, parserArg, buildArg, optsArg] = node2.arguments;
     if (!typeArg || !parserArg || !buildArg || typeArg.type === "SpreadElement" || parserArg.type === "SpreadElement" || buildArg.type === "SpreadElement") return null;
     const typeVal = anyValue(typeArg, scope, code);
     if (typeof typeVal !== "string") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
     const buildSrc = code.slice(buildArg.start, buildArg.end);
+    const collapse = optsArg !== void 0 && optsArg.type !== "SpreadElement" ? staticCollapseOption(optsArg) : false;
     try {
-      const combi = node(typeVal, inner, () => null);
+      const combi = node(typeVal, inner, () => null, collapse ? { collapse: true } : void 0);
       if (combi._def.tag === "node") combi._def.buildSrc = buildSrc;
       return combi;
     } catch {
@@ -3126,6 +3433,10 @@ function exprToCombi(node2, scope, code, mfs) {
     }
   }
   if (callee.name === "rules") return null;
+  if (callee.name === "ref") {
+    if (node2.arguments.length !== 0) return null;
+    return ref();
+  }
   if (callee.name === "parser") {
     const [optsArg, rootArg] = node2.arguments;
     if (!optsArg || !rootArg || optsArg.type === "SpreadElement" || rootArg.type === "SpreadElement") return null;
@@ -3365,6 +3676,40 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   }
   return ruleRefs;
 }
+function isDefinableRef(v2) {
+  return isCombinator(v2) && typeof v2.define === "function" && v2._def.tag === "lazy";
+}
+function evaluateRefDeclaration(init, name, scope) {
+  if (init.type !== "CallExpression") return null;
+  const callee = init.callee;
+  if (callee.type !== "Identifier" || callee.name !== "ref") return null;
+  if (init.arguments.length !== 0) return null;
+  const slot = ref();
+  scope.set(name, { combi: slot, mfSrcs: [] });
+  return slot;
+}
+function applyDefineStatement(callExpr, scope, code) {
+  if (callExpr.type !== "CallExpression") return false;
+  const callee = callExpr.callee;
+  if (callee.type !== "MemberExpression") return false;
+  const mem = callee;
+  if (mem.computed) return false;
+  if (mem.property.type !== "Identifier" || mem.property.name !== "define") return false;
+  if (mem.object.type !== "Identifier" || !mem.object.name) return false;
+  const target = scope.get(mem.object.name);
+  const refCombi = isScopeEntry(target) ? target.combi : isCombinator(target) ? target : null;
+  if (!refCombi || !isDefinableRef(refCombi)) return false;
+  const args = callExpr.arguments;
+  if (args.length !== 1 || args[0].type === "SpreadElement") return false;
+  const inner = anyValue(args[0], scope, code, []);
+  if (!isCombinator(inner)) return false;
+  try {
+    refCombi.define(inner);
+  } catch {
+    return false;
+  }
+  return true;
+}
 function referencesAny(node2, names, scope) {
   if (node2.type === "Identifier") {
     return names.has(node2.name) || scope.has(node2.name);
@@ -3439,6 +3784,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const replacements = [];
   const warnings = [];
   let anyUnresolved = false;
+  let ruleMapHolderCounter = 0;
   const lineOf = (pos) => {
     let line = 1;
     for (let i = 0; i < pos && i < code.length; i++) if (code.charCodeAt(i) === 10) line++;
@@ -3460,18 +3806,53 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
     }
-    const entries = [];
-    for (const [ruleKey, rule] of ruleMap) {
-      const compiled = compile(rule);
-      if (compiled.inlineExpression === null) {
-        warn(init.start, `${label2}: rule "${ruleKey}" couldn't be inlined`);
-        return null;
-      }
-      entries.push([ruleKey, compiled.inlineExpression]);
+    const compiled = compileRuleMap([...ruleMap]);
+    if (!compiled) {
+      warn(init.start, `${label2}: rule map couldn't be inlined`);
+      return null;
     }
-    return { entries, ruleMap };
+    return { replacement: compiled.replacement, ruleMap };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
+  const unwrapVd = (stmt) => stmt.type === "VariableDeclaration" ? stmt : stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : null;
+  const refNames = /* @__PURE__ */ new Set();
+  for (const stmt of body) {
+    const innerVd = unwrapVd(stmt);
+    if (!innerVd) continue;
+    for (const decl of innerVd.declarations) {
+      const d = decl;
+      if (!d.init || d.id.type !== "Identifier") continue;
+      const init = d.init;
+      if (init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "ref") {
+        refNames.add(d.id.name);
+      }
+    }
+  }
+  const defineRemovals = [];
+  if (refNames.size > 0) {
+    for (const stmt of body) {
+      if (stmt.type === "ExpressionStatement") {
+        const expr = stmt.expression;
+        if (applyDefineStatement(expr, scope, code)) {
+          defineRemovals.push({ start: stmt.start, end: stmt.end });
+        }
+        continue;
+      }
+      const innerVd = unwrapVd(stmt);
+      if (!innerVd) continue;
+      for (const decl of innerVd.declarations) {
+        const d = decl;
+        if (!d.init || d.id.type !== "Identifier") continue;
+        const name = d.id.name;
+        const init = d.init;
+        if (evaluateRefDeclaration(init, name, scope)) continue;
+        if (scope.has(name)) continue;
+        if (!referencesAny(init, allNames, scope)) continue;
+        const combi = evaluateExpr(init, scope, code, []);
+        if (combi) scope.set(name, { combi, mfSrcs: [] });
+      }
+    }
+  }
   for (const stmt of body) {
     let vd = null;
     let stmtStart = stmt.start;
@@ -3495,15 +3876,26 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
         if (!referencesAny(init, allNames, scope)) continue;
+        if (refNames.has(varName)) {
+          const refEntry = scope.get(varName);
+          const refCombi = refEntry?.combi ?? null;
+          if (refCombi) {
+            const compiled2 = compile(refCombi);
+            if (compiled2.inlineExpression === null) {
+              warn(init.start, `"${varName}" is a ref() that couldn't be inlined (was .define() called with a static combinator?)`);
+              continue;
+            }
+            replacements.push({ start: init.start, end: init.end, replacement: compiled2.inlineExpression });
+            continue;
+          }
+        }
         if (isRulesCall(init)) {
           const compiledRules = compileRulesFactory(init, varName);
           if (!compiledRules) continue;
           replacements.push({
             start: init.start,
             end: init.end,
-            replacement: `{
-${compiledRules.entries.map(([k, expr]) => `  ${k}: ${expr}`).join(",\n")}
-}`
+            replacement: compiledRules.replacement
           });
           continue;
         }
@@ -3538,9 +3930,8 @@ ${compiledRules.entries.map(([k, expr]) => `  ${k}: ${expr}`).join(",\n")}
         }
         const compiledRules = compileRulesFactory(init, "{ \u2026 }");
         if (!compiledRules) continue;
-        const byKey = new Map(compiledRules.entries);
         const pattern = d.id;
-        const lines = [];
+        const bindings = [];
         let allOk = true;
         for (const prop of pattern.properties) {
           const p = prop;
@@ -3555,17 +3946,21 @@ ${compiledRules.entries.map(([k, expr]) => `  ${k}: ${expr}`).join(",\n")}
             allOk = false;
             break;
           }
-          const inlineExpr = byKey.get(ruleKey);
-          if (inlineExpr === void 0) {
+          if (!compiledRules.ruleMap.has(ruleKey)) {
             warn(init.start, `destructured rule "${ruleKey}" isn't returned by the rules() factory`);
             allOk = false;
             break;
           }
-          lines.push(`${exportPrefix}${kind} ${localName} = ${inlineExpr}`);
+          bindings.push({ ruleKey, localName });
           const rule = compiledRules.ruleMap.get(ruleKey);
           if (rule) scope.set(localName, { combi: rule, mfSrcs: [] });
         }
         if (!allOk) continue;
+        const holderVar = `__rules${ruleMapHolderCounter++}`;
+        const lines = [
+          `const ${holderVar} = ${compiledRules.replacement}`,
+          ...bindings.map(({ ruleKey, localName }) => `${exportPrefix}${kind} ${localName} = ${holderVar}[${JSON.stringify(ruleKey)}]`)
+        ];
         replacements.push({
           start: stmtStart,
           end: stmtEnd,
@@ -3579,6 +3974,9 @@ ${compiledRules.entries.map(([k, expr]) => `  ${k}: ${expr}`).join(",\n")}
     imp.fullyResolved = !anyUnresolved;
   }
   const ms = new import_magic_string.default(code);
+  if (!anyUnresolved) {
+    for (const { start, end } of defineRemovals) ms.remove(start, end);
+  }
   for (const imp of macroImports) {
     if (imp.fullyResolved) {
       ms.remove(imp.start, imp.end);