parseman 0.22.0 → 0.24.0

package/dist/index.cjs

@@ -63,7 +63,6 @@ __export(index_exports, {
   parse: () => parse,
   parseDoc: () => parseDoc,
   parser: () => parser,
-  pick: () => pick,
   recover: () => recover,
   ref: () => ref,
   regex: () => regex,
@@ -432,24 +431,35 @@ function literal(value, opts = {}) {
       { lo: firstUpper, hi: firstUpper }
     ] } : firstSet2;
   }
+  const expected = [JSON.stringify(value)];
+  const parse2 = !caseInsensitive && value.length === 1 ? (() => {
+    const code = value.charCodeAt(0);
+    return function parse3(input, pos, ctx) {
+      if (input.charCodeAt(pos) === code) {
+        const span = { start: pos, end: pos + 1 };
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+        return { ok: true, value, span };
+      }
+      return failAt(ctx, expected, pos);
+    };
+  })() : function parse3(input, pos, ctx) {
+    const end = pos + value.length;
+    if (end > input.length) {
+      return failAt(ctx, expected, pos);
+    }
+    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+      const span = { start: pos, end };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
+      return { ok: true, value: matchedValue, span };
+    }
+    return failAt(ctx, expected, pos);
+  };
   return {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
-    parse(input, pos, ctx) {
-      const end = pos + value.length;
-      if (end > input.length) {
-        return failAt(ctx, [JSON.stringify(value)], pos);
-      }
-      const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
-      if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
-        const span = { start: pos, end };
-        const leaf = { _tag: "leaf", value: matchedValue, span };
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
-        return { ok: true, value: matchedValue, span };
-      }
-      return failAt(ctx, [JSON.stringify(value)], pos);
-    }
+    parse: parse2
   };
 }
 
@@ -584,8 +594,7 @@ function regex(pattern, flags = "") {
         if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
         const value = input.slice(pos, scanEnd);
         const span2 = { start: pos, end: scanEnd };
-        const leaf2 = { _tag: "leaf", value, span: span2 };
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf2);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
         return { ok: true, value, span: span2 };
       }
       anchored.lastIndex = pos;
@@ -594,8 +603,7 @@ function regex(pattern, flags = "") {
         return failAt(ctx, [`/${source}/`], pos);
       }
       const span = { start: pos, end: pos + m[0].length };
-      const leaf = { _tag: "leaf", value: m[0], span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
       return { ok: true, value: m[0], span };
     }
   };
@@ -903,8 +911,7 @@ function keywords(words, opts = {}) {
       }
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
-      const leaf = { _tag: "leaf", value, span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
       return { ok: true, value, span };
     }
   };
@@ -1394,33 +1401,136 @@ function loopScanner(arms) {
 }
 function regexTriviaScanner(parser2) {
   if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
-  const ws = whitespaceSource(parser2._def.source);
-  if (ws) return ws;
-  return blockCommentSource(parser2._def.source) ? scanBlockComment : null;
+  const source = parser2._def.source;
+  return classRunSource(source) ?? altStarSource(source) ?? (blockCommentSource(source) ? scanBlockComment : null);
 }
-function whitespaceSource(source) {
-  const m = /^\[([ \\tnrf]+)\][*+]$/.exec(source);
-  if (!m) return null;
-  const chars = /* @__PURE__ */ new Set();
-  for (let i = 0; i < m[1].length; i++) {
-    const ch = m[1][i];
-    if (ch !== "\\") {
-      chars.add(ch.charCodeAt(0));
-      continue;
+function inRanges2(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    if (cp >= r[0] && cp <= r[1]) return true;
+  }
+  return false;
+}
+function classScanner(classBody) {
+  const ranges = parseClassRanges(classBody);
+  if (!ranges) return null;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
+}
+function lineCommentScanner(commentCode) {
+  return (input, cur) => {
+    if (input.charCodeAt(cur) !== commentCode) return cur;
+    let pos = cur + 1;
+    while (pos < input.length) {
+      const cc = input.charCodeAt(pos);
+      if (cc === 10 || cc === 13) break;
+      pos++;
     }
-    const esc = m[1][++i];
-    if (esc === "t") chars.add(9);
-    else if (esc === "n") chars.add(10);
-    else if (esc === "r") chars.add(13);
-    else if (esc === "f") chars.add(12);
-    else return null;
+    return pos;
+  };
+}
+function classRunSource(source) {
+  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
+  return m ? classScanner(m[1]) : null;
+}
+function classifyTriviaArm(arm) {
+  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
+  if (cls) {
+    const ranges = parseClassRanges(cls[1]);
+    return ranges ? { kind: "class", ranges } : null;
+  }
+  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
+  if (lc) {
+    const marker = lc[1];
+    return { kind: "comment", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
   }
+  return null;
+}
+function armScanner(arm) {
+  if (arm.kind === "comment") return lineCommentScanner(arm.code);
+  const ranges = arm.ranges;
   return (input, cur) => {
     let pos = cur;
-    while (pos < input.length && chars.has(input.charCodeAt(pos))) pos++;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
+}
+function fusedTriviaScanner(ranges, commentCodes) {
+  const c0 = commentCodes[0];
+  const single = commentCodes.length === 1;
+  return (input, cur) => {
+    let pos = cur;
+    const len = input.length;
+    for (; ; ) {
+      const c = input.charCodeAt(pos);
+      if (pos < len && inRanges2(c, ranges)) {
+        pos++;
+        continue;
+      }
+      if (single ? c === c0 : commentCodes.includes(c)) {
+        pos++;
+        while (pos < len) {
+          const cc = input.charCodeAt(pos);
+          if (cc === 10 || cc === 13) break;
+          pos++;
+        }
+        continue;
+      }
+      break;
+    }
     return pos;
   };
 }
+function splitTopLevelAlts(body) {
+  const arms = [];
+  let inClass = false;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") return null;
+    else if (c === "|") {
+      arms.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  arms.push(body.slice(start));
+  return arms;
+}
+function altStarSource(source) {
+  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
+  if (!m) return null;
+  const armSrcs = splitTopLevelAlts(m[1]);
+  if (!armSrcs || armSrcs.length < 2) return null;
+  const arms = [];
+  for (const src of armSrcs) {
+    const arm = classifyTriviaArm(src);
+    if (!arm) return null;
+    arms.push(arm);
+  }
+  const ranges = [];
+  const commentCodes = [];
+  for (const arm of arms) {
+    if (arm.kind === "class") ranges.push(...arm.ranges);
+    else commentCodes.push(arm.code);
+  }
+  if (commentCodes.some((code) => inRanges2(code, ranges))) {
+    return loopScanner(arms.map(armScanner));
+  }
+  if (commentCodes.length === 0) return armScanner({ kind: "class", ranges });
+  return fusedTriviaScanner(ranges, commentCodes);
+}
 function blockCommentSource(source) {
   return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
 }
@@ -1774,6 +1884,7 @@ function markUnusedValues(root) {
 }
 
 // src/combinators/parser.ts
+var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
   ;
   r._ruleName = key;
@@ -1818,6 +1929,11 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
+  Object.defineProperty(cache, RULE_ORDER, {
+    value: Object.keys(definitions),
+    enumerable: false,
+    configurable: true
+  });
   return cache;
 }
 
@@ -5522,9 +5638,10 @@ function publicRuleWrapperSource(rule, fnSource) {
   if (labels === void 0) return fnSource;
   return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`;
 }
-function compileLinkable(ruleMapArg, ns) {
+function compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
+  const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -5555,7 +5672,8 @@ function compileLinkable(ruleMapArg, ns) {
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
-    deferFirstSetRefs: true
+    deferFirstSetRefs: true,
+    ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}
   };
   const seen = /* @__PURE__ */ new Map();
   const ruleNames = /* @__PURE__ */ new Map();
@@ -5618,7 +5736,10 @@ function compileLinkable(ruleMapArg, ns) {
       ctx.indent = 1;
       ctx.failLabel = "_pfail";
       ctx.recordFail = true;
+      const savedTrivia = ctx.activeTrivia;
+      if (rule._meta.isTrivia) ctx.activeTrivia = void 0;
       const body = emit(resolved, ctx, "_pos");
+      ctx.activeTrivia = savedTrivia;
       ctx.indent = savedIndent;
       ctx.failLabel = savedFail;
       ctx.recordFail = savedRec;
@@ -5817,6 +5938,64 @@ function escapeClassChar(ch) {
 }
 
 // src/compiler/ir-serialize.ts
+function childrenOf2(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "label":
+    case "field":
+    case "not":
+    case "node":
+    case "expect":
+      return [def.parser];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "withCtx":
+    case "recover":
+    case "unknown":
+      return [];
+  }
+}
+var ruleNameOf = (c) => c._ruleName;
+function lazyTarget(c) {
+  if (c._def.tag !== "lazy") return null;
+  try {
+    return c._def.thunk();
+  } catch {
+    return null;
+  }
+}
+var Unserializable = class extends Error {
+};
+function serializeRuleMap(ruleMap) {
+  try {
+    return new Serializer(ruleMap).run();
+  } catch (e) {
+    if (e instanceof Unserializable) {
+      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
+      return null;
+    }
+    throw e;
+  }
+}
 function evalRuleMapIR(ir) {
   const _tf = (child, src) => {
     let fn2;
@@ -5891,11 +6070,172 @@ function evalRuleMapIR(ir) {
   );
   return Object.entries(map);
 }
+var Serializer = class {
+  counts = /* @__PURE__ */ new Map();
+  selfRef = /* @__PURE__ */ new Set();
+  // combinators reached by an unnamed lazy pointing back into their own subtree
+  constName = /* @__PURE__ */ new Map();
+  emitted = /* @__PURE__ */ new Set();
+  decls = [];
+  ruleValues = /* @__PURE__ */ new Set();
+  ruleMap;
+  constructor(ruleMap) {
+    this.ruleMap = ruleMap;
+    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+  }
+  /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
+   * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
+   * `g[name]` ref — only the top-level entry is unwrapped. */
+  body(c) {
+    return c._def.tag === "lazy" && ruleNameOf(c) !== void 0 ? lazyTarget(c) ?? c : c;
+  }
+  run() {
+    for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
+    let n = 0;
+    for (const [c, count] of this.counts) {
+      if (this.ruleValues.has(c)) continue;
+      if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`);
+    }
+    const body = this.ruleMap.map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`).join(",\n");
+    if (this.decls.length === 0) return `rules((g) => ({
+${body}
+}))`;
+    return `rules((g) => {
+${this.decls.map((d) => "  " + d).join("\n")}
+  return ({
+${body}
+})
+})`;
+  }
+  /** Count identity references and flag self-referential subtrees. `active` is the
+   * set of combinators on the current DFS path (to detect a lazy pointing back). */
+  analyze(c, active) {
+    const def = c._def;
+    if (def.tag === "lazy") {
+      if (ruleNameOf(c) !== void 0) return;
+      const target = lazyTarget(c);
+      if (!target) throw new Unserializable("unresolved unnamed ref");
+      if (active.has(target)) {
+        this.selfRef.add(target);
+        return;
+      }
+      this.analyze(target, active);
+      return;
+    }
+    if (def.tag === "guard" || def.tag === "withCtx" || def.tag === "recover" || def.tag === "unknown") {
+      throw new Unserializable(`unsupported tag ${def.tag}`);
+    }
+    this.counts.set(c, (this.counts.get(c) ?? 0) + 1);
+    if ((this.counts.get(c) ?? 0) > 1) return;
+    active.add(c);
+    for (const child of childrenOf2(def)) this.analyze(child, active);
+    active.delete(c);
+  }
+  /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
+   * `selfOf` is the const currently being wrapped in a ref()/define closure — an
+   * unnamed lazy back into it emits the local ref var instead of recursing. */
+  ref(c, selfOf) {
+    const cn = this.constName.get(c);
+    if (cn) {
+      this.emitDecl(c);
+      return cn;
+    }
+    return this.expr(c, selfOf);
+  }
+  emitDecl(c) {
+    const name = this.constName.get(c);
+    if (this.emitted.has(name)) return;
+    this.emitted.add(name);
+    this.decls.push(`const ${name} = ${this.wrap(c)}`);
+  }
+  selfN = 0;
+  /** Emit `c`'s own constructor call, wrapping it in a `ref()`+`.define()` closure
+   * if it is self-referential (an unnamed lazy in its subtree points back to it) —
+   * the shape `balanced()` and other recursive library combinators build. */
+  wrap(c) {
+    if (!this.selfRef.has(c)) return this.expr(c, null);
+    const rv = `_rr${this.selfN++}`;
+    const bodyExpr = this.expr(c, { comb: c, var: rv });
+    return `(() => { const ${rv} = ref(); const _b = ${bodyExpr}; ${rv}.define(_b); return _b })()`;
+  }
+  /** Emit the constructor-call source for `c` (never a const shortcut for `c` itself). */
+  expr(c, selfOf) {
+    const def = c._def;
+    const kid = (x) => this.ref(x, selfOf);
+    switch (def.tag) {
+      case "lazy": {
+        if (ruleNameOf(c) !== void 0) return `g[${JSON.stringify(ruleNameOf(c))}]`;
+        const target = lazyTarget(c);
+        if (selfOf && target === selfOf.comb) return selfOf.var;
+        return this.ref(target, selfOf);
+      }
+      case "literal":
+        return `literal(${JSON.stringify(def.value)}${def.caseInsensitive ? ", { caseInsensitive: true }" : ""})`;
+      case "regex":
+        return `regex(${JSON.stringify(def.source)}, ${JSON.stringify(def.flags)})`;
+      case "keywords":
+        return `keywords(${JSON.stringify(def.words)}, { caseInsensitive: ${def.caseInsensitive}${def.boundary !== void 0 ? `, boundary: ${JSON.stringify(def.boundary)}` : ""} })`;
+      case "sequence":
+        return `sequence(${def.parsers.map(kid).join(", ")})`;
+      case "choice": {
+        if (def.gates.some((g) => g !== null)) throw new Unserializable("choice with a gate() has no source");
+        return `choice(${def.parsers.map(kid).join(", ")})`;
+      }
+      case "many":
+        return `many(${kid(def.parser)})`;
+      case "oneOrMore":
+        return `oneOrMore(${kid(def.parser)})`;
+      case "optional":
+        return `optional(${kid(def.parser)})`;
+      case "sepBy":
+        return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`;
+      case "not":
+        return `not(${kid(def.parser)})`;
+      case "trivia":
+        return `trivia(${kid(def.parser)})`;
+      case "token":
+        return `token(${kid(def.parser)})`;
+      case "label":
+        return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`;
+      case "field":
+        return `field(${JSON.stringify(def.name)}, ${kid(def.parser)})`;
+      case "expect":
+        return `expect(${kid(def.parser)}${def.label !== void 0 ? `, ${JSON.stringify(def.label)}` : ""})`;
+      case "skip":
+        return `skip(${kid(def.main)}, ${kid(def.skipped)})`;
+      case "scanTo":
+        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(", ")}], orEOF: ${def.orEOF} })`;
+      case "transform": {
+        if (def.fnSrc === void 0) throw new Unserializable("transform without fnSrc");
+        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`;
+      }
+      case "node": {
+        if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
+        const opts = def.unwrap || def.collapse ? `, { ${def.unwrap ? "unwrap: true" : "collapse: true"} }` : "";
+        if (def.type === void 0) {
+          if (def.buildSrc !== void 0) throw new Unserializable("inferred node build without inferred type");
+          return opts ? `node(${kid(def.parser)}, undefined${opts})` : `node(${kid(def.parser)})`;
+        }
+        if (def.buildSrc !== void 0) return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts})`;
+        return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`;
+      }
+      case "grammar": {
+        const trivia2 = def.clearTrivia ? "null" : def.triviaParser ? kid(def.triviaParser) : "undefined";
+        return `parser({ trivia: ${trivia2}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
+      }
+      case "guard":
+      case "withCtx":
+      case "recover":
+      case "unknown":
+        throw new Unserializable(`unsupported tag ${def.tag}`);
+    }
+  }
+};
 
 // src/compiler/linker.ts
 var _nsCounter = 0;
-function linkable(rulesMap, ns) {
-  const pieces = compileLinkable([...Object.entries(rulesMap)], ns ?? `_lk${_nsCounter++}_`);
+function linkable(rulesMap, ns, trivia2) {
+  const pieces = compileLinkable(Object.entries(rulesMap), ns ?? `_lk${_nsCounter++}_`, trivia2 ? { trivia: trivia2 } : void 0);
   if (!pieces) throw new Error("linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)");
   return pieces;
 }
@@ -5919,28 +6259,6 @@ function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, trivi
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
 }
-function pick(grammar, names) {
-  const p = grammar.ruleFns instanceof Map ? grammar : linkable(grammar);
-  const keep = /* @__PURE__ */ new Set();
-  const has = new Set(p.keys);
-  for (const n of names) {
-    if (!has.has(n)) throw new Error(`pick: rule "${n}" is not in this grammar (available: ${p.keys.join(", ")})`);
-  }
-  const visit = (n) => {
-    if (keep.has(n) || !has.has(n)) return;
-    keep.add(n);
-    for (const d of p.deps.get(n) ?? []) visit(d);
-  };
-  for (const n of names) visit(n);
-  const filt = (m) => new Map([...m].filter(([k]) => keep.has(k)));
-  return {
-    ...p,
-    keys: [...keep],
-    ruleFns: filt(p.ruleFns),
-    wrappers: filt(p.wrappers),
-    deps: filt(p.deps)
-  };
-}
 function fusedBody(pieces) {
   const winner = /* @__PURE__ */ new Map();
   for (const p of pieces) for (const k of p.keys) winner.set(k, p);
@@ -5960,7 +6278,7 @@ function fusedBody(pieces) {
     ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
     ...needsHostReads ? [HOST_READS_DECL] : [],
     // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
-    ...[...new Set(contributingPieces.flatMap((p) => p.prelude))],
+    ...new Set(contributingPieces.flatMap((p) => p.prelude)),
     // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
@@ -5994,12 +6312,13 @@ function fuseRules(pieces) {
   return new Function("_env", body)(env);
 }
 var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
+var COMPOSED_TRIVIA = /* @__PURE__ */ Symbol.for("parseman.composedTrivia");
 function isIRPiece(p) {
   return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
 }
-function materializePiece(p) {
+function materializePiece(p, trivia2) {
   if (!isIRPiece(p)) return p;
-  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns);
+  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, trivia2 ? { trivia: trivia2 } : void 0);
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
 }
@@ -6011,17 +6330,52 @@ function nextComposeNs(used) {
   used.add(ns);
   return ns;
 }
-function itemPieces(item, used) {
+function itemCarried(item, used, trivia2) {
   const carried = item[COMPOSED_PIECES];
-  const pieces = Array.isArray(carried) ? carried.map(materializePiece) : item.ruleFns instanceof Map ? [item] : [linkable(item, nextComposeNs(used))];
-  for (const p of pieces) used.add(p.ns);
-  return pieces;
+  if (Array.isArray(carried)) {
+    const items = carried;
+    for (const p of items) used.add(p.ns);
+    return items;
+  }
+  if (item.ruleFns instanceof Map) {
+    const p = item;
+    used.add(p.ns);
+    return [p];
+  }
+  const map = item;
+  const ns = nextComposeNs(used);
+  const entries = Object.entries(map).filter(([, val]) => {
+    const d = val._def;
+    if (d.tag !== "lazy") return true;
+    try {
+      d.thunk();
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const ir = serializeRuleMap(entries);
+  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia2)];
+}
+function composingTriviaOf(items) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    if (!item || item.ruleFns instanceof Map || item[COMPOSED_PIECES]) continue;
+    for (const v2 of Object.values(item)) {
+      const t = v2?._meta?.grammarTrivia;
+      if (t) return t;
+    }
+  }
+  return void 0;
 }
 function compose(items) {
   const used = /* @__PURE__ */ new Set();
-  const pieces = items.flatMap((item) => itemPieces(item, used));
+  const trivia2 = composingTriviaOf(items);
+  const carried = items.flatMap((item) => itemCarried(item, used, trivia2));
+  const pieces = carried.map((p) => materializePiece(p, trivia2));
   const map = fuseRules(pieces);
-  Object.defineProperty(map, COMPOSED_PIECES, { value: pieces, enumerable: false });
+  Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false });
+  if (trivia2) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia2, enumerable: false });
   return map;
 }