parseman 0.8.0 → 0.9.0

package/dist/plugin/index.js

@@ -1234,14 +1234,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;
@@ -1257,36 +1383,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) {`,
@@ -1294,80 +1414,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) => {
@@ -1400,14 +1489,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;
@@ -1655,14 +1736,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 = [];
@@ -2100,11 +2186,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(
@@ -2472,6 +2558,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);
@@ -2736,6 +2832,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,
@@ -2752,7 +2922,8 @@ 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' })
@@ -2810,6 +2981,66 @@ 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.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`,
@@ -3091,6 +3322,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;
@@ -3330,6 +3565,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);
@@ -3404,6 +3673,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++;
@@ -3425,18 +3695,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;
@@ -3460,15 +3765,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;
         }
@@ -3503,9 +3819,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;
@@ -3520,17 +3835,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,
@@ -3544,6 +3863,9 @@ ${compiledRules.entries.map(([k, expr]) => `  ${k}: ${expr}`).join(",\n")}
     imp.fullyResolved = !anyUnresolved;
   }
   const ms = new MagicString(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);