parseman 0.60.3 → 0.60.5

package/dist/cli/index.js

@@ -4167,6 +4167,336 @@ function scalarRootOf(combinator) {
   return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
 }
 
+// src/combinators/ref.ts
+function withRuleTrivia(trivia2, ctx, run) {
+  const savedLabels = ctx.triviaKindLabels;
+  ctx.trivia = trivia2;
+  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
+  try {
+    return run();
+  } finally {
+    ctx.trivia = void 0;
+    ctx.triviaKindLabels = savedLabels;
+  }
+}
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
+function ref() {
+  let resolved = null;
+  let resolvedScalar = null;
+  let ownBoundary = false;
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  const slot = {
+    _tag: "lazy",
+    _meta: meta,
+    _def: {
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw UNDEFINED_REF;
+        return resolved;
+      }
+    },
+    _parseScalar(input, pos, ctx) {
+      const scalar = resolvedScalar;
+      if (!scalar) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
+      }
+      return scalar(input, pos, ctx);
+    },
+    parse(input, pos, ctx) {
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
+      }
+      return parser2.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = p;
+      resolvedScalar = scalarOf(p);
+      ownBoundary = hasOwnTriviaBoundary(p);
+      meta.firstSet = p._meta.firstSet;
+      meta.canMatchNewline = p._meta.canMatchNewline;
+      meta.isTrivia = p._meta.isTrivia;
+      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
+      else delete meta.triviaKindLabels;
+      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
+      else delete meta.disjoint;
+    }
+  };
+  return slot;
+}
+
+// src/compiler/value-usage.ts
+function markUnusedValues(root) {
+  const seenConsumed = /* @__PURE__ */ new WeakSet();
+  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
+  const mark = (def, consumed) => {
+    if (consumed) def.valueUnused = false;
+    else if (def.valueUnused !== false) def.valueUnused = true;
+  };
+  const visit = (c, consumed) => {
+    const seen = consumed ? seenConsumed : seenUnconsumed;
+    if (seen.has(c)) return;
+    seen.add(c);
+    const def = c._def;
+    switch (def.tag) {
+      case "many":
+      case "oneOrMore":
+        mark(def, consumed);
+        visit(def.parser, consumed);
+        return;
+      case "optional":
+        visit(def.parser, consumed);
+        return;
+      case "sequence":
+        mark(def, consumed);
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "choice":
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "dispatch":
+        visit(def.selector, consumed);
+        for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
+        if (def.otherwise) visit(def.otherwise, consumed);
+        return;
+      case "node":
+        visit(def.parser, false);
+        return;
+      case "transform":
+        visit(def.parser, true);
+        return;
+      case "field":
+        visit(def.parser, true);
+        return;
+      case "sepBy":
+        visit(def.parser, true);
+        visit(def.separator, false);
+        return;
+      case "not":
+      case "peek":
+        visit(def.parser, false);
+        return;
+      case "grammar":
+        visit(def.parser, consumed);
+        if (def.triviaParser) visit(def.triviaParser, false);
+        return;
+      case "recover":
+        visit(def.parser, consumed);
+        visit(def.sentinel, false);
+        return;
+      case "token":
+        visit(def.parser, false);
+        return;
+      case "label":
+      case "trivia":
+      case "attempt":
+      case "withCtx":
+      case "expect":
+        visit(def.parser, consumed);
+        return;
+      case "leaf":
+        visit(def.parser, true);
+        return;
+      case "lazy":
+        return;
+      default:
+        return;
+    }
+  };
+  const resolveRoot = (c) => {
+    const guard = /* @__PURE__ */ new Set();
+    let cur = c;
+    while (!guard.has(cur)) {
+      const d = cur._def;
+      if (d.tag === "grammar") {
+        guard.add(cur);
+        cur = d.parser;
+        continue;
+      }
+      if (d.tag !== "lazy") return cur;
+      guard.add(cur);
+      try {
+        cur = d.thunk();
+      } catch {
+        return c;
+      }
+    }
+    return cur;
+  };
+  visit(resolveRoot(root), true);
+}
+
+// src/cst/root-trivia-scope.ts
+var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
+function refuseUnclassifiedRootScope(strict) {
+  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
+}
+
+// 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 };
+}
+var TRACK_LINES_ON = () => true;
+var TRACK_LINES_OFF = () => false;
+var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  const opaqueRootCapture = opts.rootCapture === "opaque";
+  if (opaqueRootCapture && opts.trivia === void 0) {
+    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
+  }
+  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
+  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
+  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
+  const forceCaptureTrivia = opts.captureTrivia === true;
+  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
+  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
+  const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
+  const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
+  const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
+  const grammar = {
+    _tag: "grammar",
+    _meta: {
+      ...root._meta,
+      // Trivia classification describes this grammar's own active trivia
+      // scope. A directly nested grammar may have classified trivia of its
+      // own, but that must not advertise classification for this wrapper.
+      triviaKindLabels: void 0,
+      rootTriviaClassified: void 0,
+      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
+      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
+    },
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: scopeTrivia,
+      clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+    },
+    _parseScalar: parseScalar,
+    parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
+      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
+      const trackLines = trackLinesOf(_ctx);
+      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 === void 0 ? createParseContext() : { ..._ctx };
+      ctx.trackLines = trackLines;
+      if (lineIndex) ctx._lineIndex = lineIndex;
+      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+      if (clearTrivia) {
+        ctx.trivia = void 0;
+        ctx.triviaKindLabels = void 0;
+      } else if (scopeTrivia !== void 0) {
+        ctx.trivia = scopeTrivia;
+        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
+      }
+      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
+      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
+      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
+      if (opaqueRootCapture) ctx._rootTriviaCapture = false;
+      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;
+    }
+  };
+  return grammar;
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+var _analyzed = /* @__PURE__ */ new WeakSet();
+function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
+  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
+    return combinator.parse(input);
+  }
+  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
+  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
+  const lineIndex = lineContext?.lineIndex;
+  const _errors = opts.recover ? [] : void 0;
+  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
+  const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const ctx = createParseContext();
+  ctx.trackLines = trackLines;
+  if (lineIndex) ctx._lineIndex = lineIndex;
+  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+  if (grammarTrivia !== void 0) {
+    ctx.trivia = grammarTrivia;
+    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
+  }
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (_errors !== void 0) ctx._errors = _errors;
+  if (_probe !== void 0) ctx._probe = _probe;
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
+  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+}
+
 // src/combinators/choice.ts
 function choice(...args) {
   const parsers = args.map((a) => "gate" in a ? a.combinator : a);
@@ -6464,369 +6794,106 @@ function token(root) {
     firstSet: root._meta.firstSet,
     canMatchNewline: root._meta.canMatchNewline,
     isTrivia: false
-  };
-  return {
-    _tag: "token",
-    _meta: meta,
-    _def: { tag: "token", parser: root },
-    parse(input, pos, ctx) {
-      const savedTrivia = ctx.trivia;
-      const savedKinds = ctx.triviaKindLabels;
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const savedRootTriviaLog = ctx._rootTriviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx.trivia = void 0;
-      ctx.triviaKindLabels = void 0;
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      ctx._rootTriviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx.trivia = savedTrivia;
-        ctx.triviaKindLabels = savedKinds;
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-        ctx._rootTriviaLog = savedRootTriviaLog;
-      }
-      if (!result.ok) return result;
-      const span = result.span;
-      const value = input.slice(pos, span.end);
-      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(value, span));
-      return { ok: true, value, span };
-    }
-  };
-}
-function makeLeaf(root, fn, sourceCstValue) {
-  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "leaf",
-    _meta: meta,
-    _def: {
-      tag: "leaf",
-      parser: root,
-      fn,
-      ...sourceCstValue ? { cstValue: "source" } : {}
-    },
-    parse(input, pos, ctx) {
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-      }
-      if (!result.ok) return result;
-      const value = fn(result.value, result.span);
-      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(cstValue(ctx, input, pos, result.span.end, value), result.span));
-      return { ok: true, value, span: result.span };
-    }
-  };
-}
-function leaf(root, fn) {
-  return makeLeaf(root, fn, false);
-}
-function sourceLeaf(root, fn) {
-  return makeLeaf(root, fn, true);
-}
-
-// src/compiler/value-usage.ts
-function markUnusedValues(root) {
-  const seenConsumed = /* @__PURE__ */ new WeakSet();
-  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
-  const mark = (def, consumed) => {
-    if (consumed) def.valueUnused = false;
-    else if (def.valueUnused !== false) def.valueUnused = true;
-  };
-  const visit = (c, consumed) => {
-    const seen = consumed ? seenConsumed : seenUnconsumed;
-    if (seen.has(c)) return;
-    seen.add(c);
-    const def = c._def;
-    switch (def.tag) {
-      case "many":
-      case "oneOrMore":
-        mark(def, consumed);
-        visit(def.parser, consumed);
-        return;
-      case "optional":
-        visit(def.parser, consumed);
-        return;
-      case "sequence":
-        mark(def, consumed);
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "choice":
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "dispatch":
-        visit(def.selector, consumed);
-        for (const entry of def.cases) visit(entry.parser, consumed);
-        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
-        if (def.otherwise) visit(def.otherwise, consumed);
-        return;
-      case "node":
-        visit(def.parser, false);
-        return;
-      case "transform":
-        visit(def.parser, true);
-        return;
-      case "field":
-        visit(def.parser, true);
-        return;
-      case "sepBy":
-        visit(def.parser, true);
-        visit(def.separator, false);
-        return;
-      case "not":
-      case "peek":
-        visit(def.parser, false);
-        return;
-      case "grammar":
-        visit(def.parser, consumed);
-        if (def.triviaParser) visit(def.triviaParser, false);
-        return;
-      case "recover":
-        visit(def.parser, consumed);
-        visit(def.sentinel, false);
-        return;
-      case "token":
-        visit(def.parser, false);
-        return;
-      case "label":
-      case "trivia":
-      case "attempt":
-      case "withCtx":
-      case "expect":
-        visit(def.parser, consumed);
-        return;
-      case "leaf":
-        visit(def.parser, true);
-        return;
-      case "lazy":
-        return;
-      default:
-        return;
-    }
-  };
-  const resolveRoot = (c) => {
-    const guard = /* @__PURE__ */ new Set();
-    let cur = c;
-    while (!guard.has(cur)) {
-      const d = cur._def;
-      if (d.tag === "grammar") {
-        guard.add(cur);
-        cur = d.parser;
-        continue;
-      }
-      if (d.tag !== "lazy") return cur;
-      guard.add(cur);
-      try {
-        cur = d.thunk();
-      } catch {
-        return c;
-      }
-    }
-    return cur;
-  };
-  visit(resolveRoot(root), true);
-}
-
-// src/cst/root-trivia-scope.ts
-var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
-function refuseUnclassifiedRootScope(strict) {
-  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
-}
-
-// 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 };
-}
-var TRACK_LINES_ON = () => true;
-var TRACK_LINES_OFF = () => false;
-var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  const opaqueRootCapture = opts.rootCapture === "opaque";
-  if (opaqueRootCapture && opts.trivia === void 0) {
-    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
-  }
-  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
-  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
-  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
-  const forceCaptureTrivia = opts.captureTrivia === true;
-  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
-  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
-  const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
-  const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
-  const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
-  const rootScalar = scalarOf(root);
-  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
-  const parseScalar = scalarEligible ? (input, pos, ctx) => {
-    const savedTrivia = ctx.trivia;
-    const savedLabels = ctx.triviaKindLabels;
-    if (clearTrivia) {
+  };
+  return {
+    _tag: "token",
+    _meta: meta,
+    _def: { tag: "token", parser: root },
+    parse(input, pos, ctx) {
+      const savedTrivia = ctx.trivia;
+      const savedKinds = ctx.triviaKindLabels;
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const savedRootTriviaLog = ctx._rootTriviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
       ctx.trivia = void 0;
       ctx.triviaKindLabels = void 0;
-    } else if (scopeTrivia !== void 0) {
-      ctx.trivia = scopeTrivia;
-      ctx.triviaKindLabels = scopeLabels;
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      ctx._rootTriviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx.trivia = savedTrivia;
+        ctx.triviaKindLabels = savedKinds;
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+        ctx._rootTriviaLog = savedRootTriviaLog;
+      }
+      if (!result.ok) return result;
+      const span = result.span;
+      const value = input.slice(pos, span.end);
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(value, span));
+      return { ok: true, value, span };
     }
-    const end = rootScalar(input, pos, ctx);
-    ctx.trivia = savedTrivia;
-    ctx.triviaKindLabels = savedLabels;
-    return end;
-  } : void 0;
-  let publicScalar;
-  const grammar = {
-    _tag: "grammar",
-    _meta: {
-      ...root._meta,
-      // Trivia classification describes this grammar's own active trivia
-      // scope. A directly nested grammar may have classified trivia of its
-      // own, but that must not advertise classification for this wrapper.
-      triviaKindLabels: void 0,
-      rootTriviaClassified: void 0,
-      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
-      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
-    },
+  };
+}
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
     _def: {
-      tag: "grammar",
+      tag: "leaf",
       parser: root,
-      triviaParser: scopeTrivia,
-      clearTrivia,
-      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false,
-      constructionTrackLines: trackLinesPolicy,
-      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
     },
-    _parseScalar: parseScalar,
-    parse(input, pos, _ctx) {
-      if (pos === void 0 && _ctx === void 0) {
-        publicScalar ??= scalarRootOf(grammar) ?? null;
-        if (publicScalar) {
-          const ctx2 = createParseContext();
-          const end = publicScalar(input, 0, ctx2);
-          if (end < 0) {
-            const at = ~end;
-            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
-          }
-          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
-        }
-      }
-      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
-      const trackLines = trackLinesOf(_ctx);
-      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 === void 0 ? createParseContext() : { ..._ctx };
-      ctx.trackLines = trackLines;
-      if (lineIndex) ctx._lineIndex = lineIndex;
-      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-      if (clearTrivia) {
-        ctx.trivia = void 0;
-        ctx.triviaKindLabels = void 0;
-      } else if (scopeTrivia !== void 0) {
-        ctx.trivia = scopeTrivia;
-        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
-      }
-      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
-      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
-      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
-      if (opaqueRootCapture) ctx._rootTriviaCapture = false;
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
       }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(cstValue(ctx, input, pos, result.span.end, value), result.span));
+      return { ok: true, value, span: result.span };
     }
   };
-  return grammar;
 }
-function noTrivia(root) {
-  return parser({ trivia: null }, root);
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
 }
-var _analyzed = /* @__PURE__ */ new WeakSet();
-function parse(combinator, input, opts = {}) {
-  if (!_analyzed.has(combinator)) {
-    _analyzed.add(combinator);
-    markUnusedValues(combinator);
-  }
-  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
-    return combinator.parse(input);
-  }
-  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
-  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
-  const lineIndex = lineContext?.lineIndex;
-  const _errors = opts.recover ? [] : void 0;
-  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
-  const grammarTrivia = combinator._meta.grammarTrivia;
-  const grammarScanSkip = combinator._meta.grammarScanSkip;
-  const ctx = createParseContext();
-  ctx.trackLines = trackLines;
-  if (lineIndex) ctx._lineIndex = lineIndex;
-  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-  if (grammarTrivia !== void 0) {
-    ctx.trivia = grammarTrivia;
-    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
-  }
-  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
-  if (_errors !== void 0) ctx._errors = _errors;
-  if (_probe !== void 0) ctx._probe = _probe;
-  const result = combinator.parse(input, 0, ctx);
-  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
-  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
 }
 
 // src/combinators/attempt.ts
@@ -13029,73 +13096,6 @@ function literal(value, opts = {}) {
   };
 }
 
-// src/combinators/ref.ts
-function withRuleTrivia(trivia2, ctx, run) {
-  const savedLabels = ctx.triviaKindLabels;
-  ctx.trivia = trivia2;
-  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
-  try {
-    return run();
-  } finally {
-    ctx.trivia = void 0;
-    ctx.triviaKindLabels = savedLabels;
-  }
-}
-var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
-function ref() {
-  let resolved = null;
-  let resolvedScalar = null;
-  let ownBoundary = false;
-  const meta = {
-    firstSet: any(),
-    canMatchNewline: true,
-    isTrivia: false
-  };
-  const slot = {
-    _tag: "lazy",
-    _meta: meta,
-    _def: {
-      tag: "lazy",
-      thunk: () => {
-        if (!resolved) throw UNDEFINED_REF;
-        return resolved;
-      }
-    },
-    _parseScalar(input, pos, ctx) {
-      const scalar = resolvedScalar;
-      if (!scalar) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
-      }
-      return scalar(input, pos, ctx);
-    },
-    parse(input, pos, ctx) {
-      const parser2 = resolved;
-      if (!parser2) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
-      }
-      return parser2.parse(input, pos, ctx);
-    },
-    define(p) {
-      if (resolved) throw new Error("ref<T>() already defined");
-      resolved = p;
-      resolvedScalar = scalarOf(p);
-      ownBoundary = hasOwnTriviaBoundary(p);
-      meta.firstSet = p._meta.firstSet;
-      meta.canMatchNewline = p._meta.canMatchNewline;
-      meta.isTrivia = p._meta.isTrivia;
-      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
-      else delete meta.triviaKindLabels;
-      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
-      else delete meta.disjoint;
-    }
-  };
-  return slot;
-}
-
 // src/combinators/scanTo.ts
 import { PlainLeaf as PlainLeaf8, PlainSpan as PlainSpan9 } from "../cst/plain.js";
 function resolveScanSkip(explicitSkip, raw, ctx) {
@@ -13415,7 +13415,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.3";
+var PARSEMAN_VERSION = "0.60.5";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";