parseman 0.42.0 → 0.43.0

package/dist/spec/index.js

@@ -357,92 +357,6 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
-// src/combinators/parser.ts
-var RULE_ORDER = "__parsemanRuleOrder";
-function tagRule(r, key) {
-  ;
-  r._ruleName = key;
-  if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
-}
-function isDefinableRef(v) {
-  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
-}
-function ruleNameOf(r) {
-  return r._ruleName;
-}
-function isNamedRuleRefForAnotherRule(r, key) {
-  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
-  return name !== void 0 && name !== key;
-}
-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) {
-      if (typeof key !== "string") return void 0;
-      const record = target;
-      if (!(key in record)) {
-        const r = ref();
-        tagRule(r, key);
-        record[key] = r;
-      }
-      return record[key];
-    }
-  });
-  const definitions = factory(proxy);
-  for (const key of Object.keys(definitions)) {
-    const placeholder = cache[key];
-    const parser2 = definitions[key];
-    if (placeholder === parser2) {
-      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
-    }
-    if (isDefinableRef(placeholder)) {
-      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
-      placeholder.define(parser2);
-      placeholder._meta.firstSet = parser2._meta.firstSet;
-      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
-    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
-      const alias = ref();
-      tagRule(alias, key);
-      alias.define(parser2);
-      alias._meta.firstSet = parser2._meta.firstSet;
-      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
-      cache[key] = alias;
-    } else {
-      tagRule(parser2, key);
-      cache[key] = parser2;
-    }
-  }
-  if (options?.trivia != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
-    }
-  }
-  if (options?.scanSkip != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
-    }
-  }
-  if (options?.hostMode === "cst") {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
-    }
-  }
-  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;
-}
-
 // src/line-index.ts
 function createLineIndex() {
   return { lineStarts: [0] };
@@ -1110,38 +1024,432 @@ function codesToFirstSet(codes) {
     if (codes[i] === hi + 1) {
       hi = codes[i];
     } else {
-      ranges.push({ lo, hi });
-      lo = hi = codes[i];
+      ranges.push({ lo, hi });
+      lo = hi = codes[i];
+    }
+  }
+  ranges.push({ lo, hi });
+  return { kind: "ranges", ranges };
+}
+function inFirstSet(code, fs) {
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
+function areDisjoint(sets) {
+  if (sets.some((s) => s.kind === "any")) return false;
+  for (let i = 0; i < sets.length; i++)
+    for (let j2 = i + 1; j2 < sets.length; j2++)
+      if (intersects(sets[i], sets[j2])) return false;
+  return true;
+}
+function buildAsciiDispatch(parsers) {
+  const table = Array(128).fill(-1);
+  for (let i = 0; i < parsers.length; i++) {
+    const fs = parsers[i]._meta.firstSet;
+    if (fs.kind !== "ranges") continue;
+    for (const { lo, hi } of fs.ranges) {
+      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
+        table[code] = i;
+      }
+    }
+  }
+  return table;
+}
+
+// src/cst/trivia-kinds.ts
+function unwrapTrivia(p) {
+  let cur = p;
+  while (cur._def.tag === "trivia") cur = cur._def.parser;
+  return cur;
+}
+function peelLabel(p) {
+  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
+  return null;
+}
+function analyzeLabeledTrivia(trivia2) {
+  let core = unwrapTrivia(trivia2);
+  let minRepeats = 1;
+  if (core._def.tag === "oneOrMore") {
+    core = core._def.parser;
+    minRepeats = 1;
+  } else if (core._def.tag === "many") {
+    core = core._def.parser;
+    minRepeats = 0;
+  }
+  const arms = [];
+  if (core._def.tag === "choice") {
+    for (let i = 0; i < core._def.parsers.length; i++) {
+      const peeled = peelLabel(core._def.parsers[i]);
+      if (!peeled) return null;
+      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
+    }
+  } else {
+    const peeled = peelLabel(core);
+    if (!peeled) return null;
+    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
+  }
+  return { labels: arms.map((a) => a.label), arms, minRepeats };
+}
+function matchArmAt(input, pos, arm) {
+  const r = arm.parse(input, pos, { trackLines: false });
+  if (!r.ok || r.span.end <= pos) return null;
+  return { end: r.span.end };
+}
+function scanLabeledTriviaChunks(input, cur, spec) {
+  const chunks = [];
+  let pos = cur;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      const m = matchArmAt(input, pos, arm.parser);
+      if (m) {
+        matched = { end: m.end, kindIndex: arm.kindIndex };
+        break;
+      }
+    }
+    if (!matched) break;
+    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
+    pos = matched.end;
+  }
+  if (chunks.length < spec.minRepeats) {
+    return { end: cur, chunks: [] };
+  }
+  return { end: pos, chunks };
+}
+function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
+  const chunks = [];
+  let pos = cur;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {
+      const start = pos;
+      pos++;
+      while (pos < input.length) {
+        const c2 = input.charCodeAt(pos);
+        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++;
+        else break;
+      }
+      chunks.push({ start, end: pos, kindIndex: wsKind });
+      continue;
+    }
+    if (c === 47 && input.charCodeAt(pos + 1) === 42) {
+      let j2 = pos + 2;
+      while (j2 + 1 < input.length && !(input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47)) j2++;
+      if (j2 + 1 < input.length && input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47) {
+        const start = pos;
+        pos = j2 + 2;
+        chunks.push({ start, end: pos, kindIndex: commentKind });
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+  return { end: pos, chunks };
+}
+function tryFastLabeledScan(input, cur, trivia2) {
+  const spec = analyzeLabeledTrivia(trivia2);
+  if (!spec || spec.arms.length !== 2) return null;
+  const wsArm = spec.arms.find((a) => {
+    const src = getCoreRegexDef(a.parser)?.source;
+    return src != null && !src.includes("\\*");
+  });
+  const commentArm = spec.arms.find((a) => {
+    const src = getCoreRegexDef(a.parser)?.source;
+    return src != null && src.includes("\\*");
+  });
+  if (!wsArm || !commentArm) return null;
+  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] };
+  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+}
+function recordTriviaChunks(ctx, chunks) {
+  const kinds = ctx.triviaKindLabels;
+  const mask = ctx._triviaCaptureMask;
+  for (const ch of chunks) {
+    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
+      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch.kindIndex) !== 0) {
+        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+      }
+    }
+  }
+}
+function triviaKindMask(labels, keep) {
+  if (!labels) return void 0;
+  let mask = 0;
+  for (const name of keep) {
+    const idx = labels.indexOf(name);
+    if (idx >= 0) mask |= 1 << idx;
+  }
+  return mask;
+}
+
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false
+    },
+    parse(input, pos, _ctx) {
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...lineIndex ? { _lineIndex: lineIndex } : {},
+        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
+        ...clearTrivia ? {
+          trivia: void 0,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
+        // Kind-filter for per-node capture. Resolve against this scope's trivia
+        // labels — this parser's own trivia if it declares one, else the INHERITED
+        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
+        // trivia is inherited rather than re-declared here. No labels → undefined
+        // (capture all).
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+}
+
+// src/cst/reflection.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "recover":
+    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 "literal":
+    case "regex":
+    case "keywords":
+    case "routed":
+    case "guard":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  for (const [, rule] of ruleMap) {
+    if (!followLazy && rule._def.tag === "lazy") {
+      try {
+        const resolved = rule._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function attachGrammarReflection(grammar, reflection) {
+  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
+  return grammar;
+}
+
+// src/combinators/parser.ts
+var RULE_ORDER = "__parsemanRuleOrder";
+function tagRule(r, key) {
+  ;
+  r._ruleName = key;
+  if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
+}
+function isDefinableRef(v) {
+  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
+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) {
+      if (typeof key !== "string") return void 0;
+      const record = target;
+      if (!(key in record)) {
+        const r = ref();
+        tagRule(r, key);
+        record[key] = r;
+      }
+      return record[key];
+    }
+  });
+  const definitions = factory(proxy);
+  for (const key of Object.keys(definitions)) {
+    const placeholder = cache[key];
+    const parser2 = definitions[key];
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
+      placeholder.define(parser2);
+      placeholder._meta.firstSet = parser2._meta.firstSet;
+      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
+    } else {
+      tagRule(parser2, key);
+      cache[key] = parser2;
     }
   }
-  ranges.push({ lo, hi });
-  return { kind: "ranges", ranges };
-}
-function inFirstSet(code, fs) {
-  if (fs.kind === "any") return true;
-  if (fs.kind === "empty") return false;
-  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
-}
-function areDisjoint(sets) {
-  if (sets.some((s) => s.kind === "any")) return false;
-  for (let i = 0; i < sets.length; i++)
-    for (let j2 = i + 1; j2 < sets.length; j2++)
-      if (intersects(sets[i], sets[j2])) return false;
-  return true;
-}
-function buildAsciiDispatch(parsers) {
-  const table = Array(128).fill(-1);
-  for (let i = 0; i < parsers.length; i++) {
-    const fs = parsers[i]._meta.firstSet;
-    if (fs.kind !== "ranges") continue;
-    for (const { lo, hi } of fs.ranges) {
-      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
-        table[code] = i;
+  if (options?.trivia != null) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
+    }
+  }
+  if (options?.scanSkip != null) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
+    }
+  }
+  if (options?.hostMode === "cst") {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
+    }
+  }
+  if (options?.trackLines === true) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
+    }
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
+        const wrapped = parser({ trackLines: true }, rule);
+        tagRule(wrapped, key);
+        wrapped._meta.grammarTrackLines = true;
+        cache[key] = wrapped;
       }
     }
   }
-  return table;
+  for (const key of Object.keys(definitions)) {
+    markUnusedValues(cache[key]);
+  }
+  Object.defineProperty(cache, RULE_ORDER, {
+    value: Object.keys(definitions),
+    enumerable: false,
+    configurable: true
+  });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
+  return cache;
 }
 
 // src/analysis/duplication.ts
@@ -1396,135 +1704,6 @@ function regex(pattern, flags = "") {
   };
 }
 
-// src/cst/trivia-kinds.ts
-function unwrapTrivia(p) {
-  let cur = p;
-  while (cur._def.tag === "trivia") cur = cur._def.parser;
-  return cur;
-}
-function peelLabel(p) {
-  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
-  return null;
-}
-function analyzeLabeledTrivia(trivia2) {
-  let core = unwrapTrivia(trivia2);
-  let minRepeats = 1;
-  if (core._def.tag === "oneOrMore") {
-    core = core._def.parser;
-    minRepeats = 1;
-  } else if (core._def.tag === "many") {
-    core = core._def.parser;
-    minRepeats = 0;
-  }
-  const arms = [];
-  if (core._def.tag === "choice") {
-    for (let i = 0; i < core._def.parsers.length; i++) {
-      const peeled = peelLabel(core._def.parsers[i]);
-      if (!peeled) return null;
-      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
-    }
-  } else {
-    const peeled = peelLabel(core);
-    if (!peeled) return null;
-    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
-  }
-  return { labels: arms.map((a) => a.label), arms, minRepeats };
-}
-function matchArmAt(input, pos, arm) {
-  const r = arm.parse(input, pos, { trackLines: false });
-  if (!r.ok || r.span.end <= pos) return null;
-  return { end: r.span.end };
-}
-function scanLabeledTriviaChunks(input, cur, spec) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    let matched = null;
-    for (const arm of spec.arms) {
-      const m = matchArmAt(input, pos, arm.parser);
-      if (m) {
-        matched = { end: m.end, kindIndex: arm.kindIndex };
-        break;
-      }
-    }
-    if (!matched) break;
-    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
-    pos = matched.end;
-  }
-  if (chunks.length < spec.minRepeats) {
-    return { end: cur, chunks: [] };
-  }
-  return { end: pos, chunks };
-}
-function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    const c = input.charCodeAt(pos);
-    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {
-      const start = pos;
-      pos++;
-      while (pos < input.length) {
-        const c2 = input.charCodeAt(pos);
-        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++;
-        else break;
-      }
-      chunks.push({ start, end: pos, kindIndex: wsKind });
-      continue;
-    }
-    if (c === 47 && input.charCodeAt(pos + 1) === 42) {
-      let j2 = pos + 2;
-      while (j2 + 1 < input.length && !(input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47)) j2++;
-      if (j2 + 1 < input.length && input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47) {
-        const start = pos;
-        pos = j2 + 2;
-        chunks.push({ start, end: pos, kindIndex: commentKind });
-        continue;
-      }
-      break;
-    }
-    break;
-  }
-  return { end: pos, chunks };
-}
-function tryFastLabeledScan(input, cur, trivia2) {
-  const spec = analyzeLabeledTrivia(trivia2);
-  if (!spec || spec.arms.length !== 2) return null;
-  const wsArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && !src.includes("\\*");
-  });
-  const commentArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && src.includes("\\*");
-  });
-  if (!wsArm || !commentArm) return null;
-  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
-  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] };
-  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
-}
-function recordTriviaChunks(ctx, chunks) {
-  const kinds = ctx.triviaKindLabels;
-  const mask = ctx._triviaCaptureMask;
-  for (const ch of chunks) {
-    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
-    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
-      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch.kindIndex) !== 0) {
-        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
-      }
-    }
-  }
-}
-function triviaKindMask(labels, keep) {
-  if (!labels) return void 0;
-  let mask = 0;
-  for (const name of keep) {
-    const idx = labels.indexOf(name);
-    if (idx >= 0) mask |= 1 << idx;
-  }
-  return mask;
-}
-
 // src/combinators/trivia-skip.ts
 var NOOP_COMMIT = () => {
 };
@@ -2896,13 +3075,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const collapse = opts?.collapse === true;
   const captureTrivia = opts?.captureTrivia === true;
   const trailingTrivia = opts?.trailingTrivia === true;
+  const tags = opts?.tags;
   if (unwrap && collapse) {
     throw new Error("node() options cannot set both unwrap and collapse");
   }
   if (project !== void 0 && (unwrap || collapse)) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
@@ -2948,7 +3128,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState) : projectChild(children, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState) : build(children, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children };
+      const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, hostState, tags) : build(children, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children };
       const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -2958,71 +3138,6 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   };
 }
 
-// src/combinators/grammar.ts
-function annotateResultLines(result, index) {
-  const annotated = { ...result, span: annotateSpan(result.span, index) };
-  const errors = annotated.errors;
-  if (errors) {
-    ;
-    annotated.errors = errors.map((error) => ({
-      ...error,
-      span: annotateSpan(error.span, index)
-    }));
-  }
-  return annotated;
-}
-function createParseLineContext(input, pos) {
-  const lineIndex = createLineIndex();
-  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
-  return { lineIndex, lineScannedTo: pos };
-}
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  return {
-    _tag: "grammar",
-    _meta: root._meta,
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
-      clearTrivia,
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
-    },
-    parse(input, pos, _ctx) {
-      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
-      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
-      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
-      const ctx = {
-        ..._ctx,
-        trackLines,
-        ...lineIndex ? { _lineIndex: lineIndex } : {},
-        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
-        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
-        ...clearTrivia ? {
-          trivia: void 0,
-          triviaKindLabels: void 0
-        } : opts.trivia != null ? {
-          trivia: opts.trivia,
-          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
-        } : {},
-        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
-        // Kind-filter for per-node capture. Resolve against this scope's trivia
-        // labels — this parser's own trivia if it declares one, else the INHERITED
-        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
-        // trivia is inherited rather than re-declared here. No labels → undefined
-        // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
-      };
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
-      }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-    }
-  };
-}
-
 // src/combinators/token.ts
 function token(root) {
   const meta = {
@@ -3305,15 +3420,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children] };
+function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children] };
 }
-function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
     return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children2 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  const materializeTags = typeOrOptions?.tags === true;
+  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children2 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;