parseman 0.21.0 → 0.23.0

package/dist/index.d.ts

@@ -18,7 +18,7 @@ export type { ParseOptions, ParserOptions, ParsemanParser } from './combinators/
 export { token } from './combinators/token.ts';
 export { compile } from './compiler/codegen.ts';
 export type { CompiledParser, LinkablePieces } from './compiler/codegen.ts';
-export { compose, pick, cstBuildHost } from './compiler/linker.ts';
+export { compose, cstBuildHost } from './compiler/linker.ts';
 export type { CstBuildHostOptions, FusedRule } from './compiler/linker.ts';
 export { buildLineIndex, offsetToLineCol, annotateSpan } from './compiler/line-index.ts';
 export type { LineIndex } from './compiler/line-index.ts';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1690,7 +1690,9 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
-function rules(factory) {
+function rules(a, b) {
+  const factory = typeof a === "function" ? a : b;
+  const options = typeof a === "function" ? b : a;
   const cache = {};
   const proxy = new Proxy(cache, {
     get(target, key) {
@@ -1718,6 +1720,12 @@ function rules(factory) {
       cache[key] = parser2;
     }
   }
+  if (options?.trivia !== void 0) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
+    }
+  }
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
@@ -2060,8 +2068,10 @@ function parse(combinator, input, opts = {}) {
   const trackLines = opts.trackLines ?? false;
   const _errors = opts.recover ? [] : void 0;
   const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
   const ctx = {
     trackLines,
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
     ..._errors !== void 0 ? { _errors } : {},
     ..._probe !== void 0 ? { _probe } : {}
   };
@@ -5327,6 +5337,7 @@ function ruleDependencies(ruleMap) {
 }
 function compile(combinator, mapFnSources) {
   markUnusedValues(combinator);
+  const grammarTrivia = combinator._meta.grammarTrivia;
   const ctx = {
     vars: 0,
     indent: 1,
@@ -5345,7 +5356,8 @@ function compile(combinator, mapFnSources) {
     triviaFnNames: /* @__PURE__ */ new Map(),
     namedFnDecls: [],
     capturing: hasNodeDef(combinator),
-    lazyUsage: analyzeLazyUsage(combinator)
+    lazyUsage: analyzeLazyUsage(combinator),
+    ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}
   };
   const r = emit(combinator, ctx, "_pos");
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
@@ -5421,9 +5433,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;
@@ -5454,7 +5467,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();
@@ -5517,7 +5531,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;
@@ -5716,6 +5733,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;
@@ -5790,11 +5865,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;
 }
@@ -5818,28 +6054,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);
@@ -5859,7 +6073,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))
   ];
@@ -5893,12 +6107,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;
 }
@@ -5910,17 +6125,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;
 }
 
@@ -6203,12 +6453,14 @@ function run(entry, input, options = {}) {
   }
   const triviaLog = [];
   const errors = [];
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
   const ctx = {
     trackLines: false,
     _triviaLog: triviaLog,
     _errors: errors,
     build: options.build,
     state: options.state,
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
     ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {}
   };
   const r = invoke(entry, input, 0, ctx);
@@ -6669,7 +6921,6 @@ export {
   parse,
   parseDoc,
   parser,
-  pick,
   recover,
   ref,
   regex,