parseman 0.47.1 → 0.48.1

package/dist/language-service/index.cjs

@@ -1,1304 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/language-service/index.ts
-var language_service_exports = {};
-__export(language_service_exports, {
-  languageService: () => languageService
-});
-module.exports = __toCommonJS(language_service_exports);
-
-// src/line-index.ts
-function recordLineRange(index, input, start, end) {
-  const lineStarts = index.lineStarts;
-  for (let i = start; i < end; i++) {
-    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
-  }
-}
-function recordLineRangeFromContext(ctx, input, _startHint, end) {
-  if (!ctx.trackLines) return;
-  const from = ctx._lineScannedTo ?? 0;
-  if (end <= from) return;
-  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
-  if (!index) return;
-  recordLineRange(index, input, from, end);
-  ctx._lineScannedTo = end;
-}
-function offsetToLineCol(index, offset) {
-  const { lineStarts } = index;
-  let lo = 0;
-  let hi = lineStarts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (lineStarts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
-  }
-  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
-}
-function annotateSpan(span, index) {
-  const s = offsetToLineCol(index, span.start);
-  const e = offsetToLineCol(index, span.end);
-  return {
-    ...span,
-    startLine: s.line,
-    startColumn: s.col,
-    endLine: e.line,
-    endColumn: e.col
-  };
-}
-function annotateSpanFromLineContext(span, ctx) {
-  if (!ctx.trackLines) return span;
-  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
-  return index ? annotateSpan(span, index) : span;
-}
-
-// src/cst/capture-buffer.ts
-function cstCaptureActive(ctx) {
-  return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
-}
-function pushCstChild(ctx, built, rawEntry2) {
-  const b = ctx._cstBuf;
-  if (b) {
-    if (b.rawOnly !== true) {
-      if (b.ch) b.ch.push(built);
-      else if (b.single !== void 0) {
-        b.ch = [b.single, built];
-        b.single = void 0;
-      } else b.single = built;
-    }
-    if (b.raw) b.raw.push(rawEntry2);
-    else if (b.rawSingle !== void 0) {
-      b.raw = [b.rawSingle, rawEntry2];
-      b.rawSingle = void 0;
-    } else b.rawSingle = rawEntry2;
-    return;
-  }
-  if (ctx._cstChildren) ctx._cstChildren.push(built);
-  else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
-  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
-}
-
-// src/recovery/scan.ts
-function probeAt(sentinel, input, pos, ctx) {
-  const s = {
-    _probe: ctx._probe,
-    _errors: ctx._errors,
-    _cstLeaves: ctx._cstLeaves,
-    _cstChildren: ctx._cstChildren,
-    _cstRawChildren: ctx._cstRawChildren,
-    _cstTriviaLog: ctx._cstTriviaLog,
-    _triviaLog: ctx._triviaLog,
-    _rootTriviaLog: ctx._rootTriviaLog,
-    _fields: ctx._fields,
-    _cstBuf: ctx._cstBuf,
-    _tolerant: ctx._tolerant,
-    _sync: ctx._sync
-  };
-  ctx._probe = void 0;
-  ctx._errors = void 0;
-  ctx._cstLeaves = void 0;
-  ctx._cstChildren = void 0;
-  ctx._cstRawChildren = void 0;
-  ctx._cstTriviaLog = void 0;
-  ctx._triviaLog = void 0;
-  ctx._rootTriviaLog = void 0;
-  ctx._fields = void 0;
-  ctx._cstBuf = void 0;
-  ctx._tolerant = void 0;
-  ctx._sync = void 0;
-  try {
-    return sentinel.parse(input, pos, ctx).ok;
-  } finally {
-    ctx._probe = s._probe;
-    ctx._errors = s._errors;
-    ctx._cstLeaves = s._cstLeaves;
-    ctx._cstChildren = s._cstChildren;
-    ctx._cstRawChildren = s._cstRawChildren;
-    ctx._cstTriviaLog = s._cstTriviaLog;
-    ctx._triviaLog = s._triviaLog;
-    ctx._rootTriviaLog = s._rootTriviaLog;
-    ctx._fields = s._fields;
-    ctx._cstBuf = s._cstBuf;
-    ctx._tolerant = s._tolerant;
-    ctx._sync = s._sync;
-  }
-}
-function orSentinel(a, b) {
-  if (b === void 0) return a;
-  return {
-    _tag: "orSentinel",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos, ctx) {
-      const ra = a.parse(input, pos, ctx);
-      if (ra.ok) return ra;
-      return b.parse(input, pos, ctx);
-    }
-  };
-}
-function firstSetSentinel(fs) {
-  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
-  const ranges = fs.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos) {
-      const code = pos < input.length ? input.codePointAt(pos) : void 0;
-      if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
-      }
-      return { ok: false, expected: [], span: { start: pos, end: pos } };
-    }
-  };
-}
-function recoverScan(input, from, ctx, sync, expected) {
-  let scanPos = from;
-  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const span = { start: from, end: scanPos };
-  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
-  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-  ctx._errors?.push(error);
-  return { error, end: scanPos };
-}
-function matchesAt(sentinel, input, pos, ctx) {
-  return probeAt(sentinel, input, pos, ctx);
-}
-function captureError(ctx, error) {
-  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
-}
-var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
-
-// src/parse-context.ts
-function createParseContext() {
-  return {
-    trivia: void 0,
-    scanSkip: void 0,
-    triviaKindLabels: void 0,
-    captureTrivia: void 0,
-    _triviaCaptureMask: void 0,
-    trackLines: false,
-    state: void 0,
-    build: void 0,
-    _errors: void 0,
-    _tolerant: void 0,
-    _sync: void 0,
-    _rec: void 0,
-    _fe: void 0,
-    _fx: void 0,
-    _fc: void 0,
-    _probe: void 0,
-    _cstChildren: void 0,
-    _cstLeaves: void 0,
-    _cstRawChildren: void 0,
-    _triviaLog: void 0,
-    _rootTriviaLog: void 0,
-    _rootTriviaKindIndex: void 0,
-    _rootTriviaStrictScopes: void 0,
-    _rootTriviaCapture: void 0,
-    _cstTriviaLog: void 0,
-    _fields: void 0,
-    _cstBuf: void 0,
-    _routed: void 0,
-    _lineStarts: void 0,
-    _lineIndex: void 0,
-    _lineScannedTo: void 0,
-    _grammarCoverage: void 0,
-    _grammarTrace: void 0
-  };
-}
-
-// src/cst/trivia-entries.ts
-var EMPTY_INDICES = Object.freeze([]);
-var EMPTY_GAPS = Object.freeze([]);
-var SELECTED_ROOT_STRIDE = 5;
-function buildRootTriviaIndex(log, labels) {
-  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
-  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
-  const ownedRangeStart = (i) => log[markerOffset(i)];
-  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
-  const markerStart = (i) => log[markerOffset(i) + 2];
-  const markerEnd = (i) => log[markerOffset(i) + 3];
-  const markerKind = (i) => log[markerOffset(i) + 4];
-  const entries = {
-    length,
-    labels,
-    stride: SELECTED_ROOT_STRIDE,
-    start: markerStart,
-    end: markerEnd,
-    insertIndex: () => void 0,
-    kindIndex: markerKind,
-    kind(i) {
-      return labels[markerKind(i)];
-    },
-    text(i, input) {
-      return input.slice(markerStart(i), markerEnd(i));
-    }
-  };
-  const lowerBound = (offset, by) => {
-    let lo = 0;
-    let hi = length;
-    while (lo < hi) {
-      const mid = lo + hi >>> 1;
-      if (by(mid) < offset) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo;
-  };
-  const gapRowsAt = (offset, direction) => {
-    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
-    let first = lowerBound(offset, edge);
-    if (first === length || edge(first) !== offset) return void 0;
-    const start = ownedRangeStart(first);
-    const end = ownedRangeEnd(first);
-    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
-    let last = first + 1;
-    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
-    return [first, last];
-  };
-  const indices = (first, last) => {
-    const out = [];
-    for (let i = first; i < last; i++) out.push(i);
-    return out;
-  };
-  const makeGap = (first, last) => {
-    const start = ownedRangeStart(first);
-    const end = ownedRangeEnd(first);
-    let entryIndices;
-    return {
-      start,
-      end,
-      get entryIndices() {
-        return entryIndices ??= indices(first, last);
-      },
-      hasKind(kind) {
-        for (let i = first; i < last; i++) {
-          if (labels[markerKind(i)] === kind) return true;
-        }
-        return false;
-      },
-      text(input) {
-        return input.slice(start, end);
-      }
-    };
-  };
-  let maps;
-  const getMaps = () => {
-    if (maps !== void 0) return maps;
-    const before = /* @__PURE__ */ new Map();
-    const after = /* @__PURE__ */ new Map();
-    const beforeGaps = /* @__PURE__ */ new Map();
-    const afterGaps = /* @__PURE__ */ new Map();
-    const gaps = [];
-    for (let first = 0; first < length; ) {
-      let last = first + 1;
-      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
-      const gap = makeGap(first, last);
-      gaps.push(gap);
-      afterGaps.set(gap.start, gap);
-      beforeGaps.set(gap.end, gap);
-      after.set(gap.start, [...gap.entryIndices]);
-      before.set(gap.end, [...gap.entryIndices]);
-      first = last;
-    }
-    maps = { before, after, beforeGaps, afterGaps, gaps };
-    return maps;
-  };
-  return {
-    entries,
-    labels,
-    get before() {
-      return getMaps().before;
-    },
-    get after() {
-      return getMaps().after;
-    },
-    entryIndicesBefore(offset) {
-      const rows = gapRowsAt(offset, "before");
-      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
-    },
-    entryIndicesAfter(offset) {
-      const rows = gapRowsAt(offset, "after");
-      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
-    },
-    gapBefore(offset) {
-      const rows = gapRowsAt(offset, "before");
-      return rows ? makeGap(rows[0], rows[1]) : void 0;
-    },
-    gapAfter(offset) {
-      const rows = gapRowsAt(offset, "after");
-      return rows ? makeGap(rows[0], rows[1]) : void 0;
-    },
-    gaps() {
-      return getMaps().gaps;
-    },
-    gapsWithKind(kind) {
-      const kinds = typeof kind === "string" ? [kind] : kind;
-      const matches2 = [];
-      for (let first = 0; first < length; ) {
-        let last = first + 1;
-        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
-        let matched = false;
-        for (let i = first; i < last && !matched; i++) {
-          const label2 = labels[markerKind(i)];
-          for (const kind2 of kinds) {
-            if (label2 === kind2) {
-              matched = true;
-              break;
-            }
-          }
-        }
-        if (matched) matches2.push(makeGap(first, last));
-        first = last;
-      }
-      return matches2.length === 0 ? EMPTY_GAPS : matches2;
-    }
-  };
-}
-
-// src/cst/host-mode.ts
-var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
-var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
-function assertHostModeCompatible(mode, build, hostBranchElided = true) {
-  const isCstHost = build?._parsemanCstOutput === true;
-  if (mode === "ast" && isCstHost && hostBranchElided) {
-    throw new Error(
-      "parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes build through their own `build` callbacks and no positioned-CST branch was emitted. It cannot be driven with a positioned-CST host (cstBuildHost / a language-service host). Compile a second artifact from the SAME grammar with `compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second `rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead."
-    );
-  }
-  if (mode === "cst" && !isCstHost) {
-    throw new Error(
-      'parseman: this parser was compiled for host mode "cst", so every node builds through a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use an artifact compiled with the default `hostMode: "ast"` to get the grammar\'s own AST.'
-    );
-  }
-}
-
-// src/functional/run.ts
-var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
-var REMOVED_RUN_RESULT_FIELDS = [
-  [
-    "triviaMap",
-    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
-  ],
-  [
-    "triviaLog",
-    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
-  ],
-  [
-    "triviaKindLabels",
-    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
-  ]
-];
-var RunResultRecord = class {
-  constructor(ok, value, span, expected, errors, unconsumedFrom) {
-    this.ok = ok;
-    this.value = value;
-    this.span = span;
-    this.expected = expected;
-    this.errors = errors;
-    this.unconsumedFrom = unconsumedFrom;
-  }
-};
-var RunResultWithRootTrivia = class {
-  constructor(ok, value, span, expected, errors, rootTrivia, unconsumedFrom) {
-    this.ok = ok;
-    this.value = value;
-    this.span = span;
-    this.expected = expected;
-    this.errors = errors;
-    this.rootTrivia = rootTrivia;
-    this.unconsumedFrom = unconsumedFrom;
-  }
-};
-for (const proto of [RunResultRecord.prototype, RunResultWithRootTrivia.prototype]) {
-  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
-    Object.defineProperty(proto, name, {
-      configurable: true,
-      enumerable: false,
-      get() {
-        throw new TypeError(
-          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
-        );
-      }
-    });
-  }
-}
-var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
-function ambientTriviaFromRunnable(r) {
-  if (!r) return void 0;
-  if (typeof r === "function") return r._meta?.grammarTrivia;
-  if (r._meta.isTrivia) return void 0;
-  return r._meta.grammarTrivia ?? (r._def.tag === "grammar" ? r._def.triviaParser : void 0);
-}
-function triviaKindLabelsFromRunnable(r) {
-  if (!r) return void 0;
-  if (typeof r === "function") return r._meta?.triviaKindLabels;
-  const grammarTrivia = r._meta.grammarTrivia;
-  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
-}
-function rootTriviaClassifiedFromRunnable(r) {
-  if (!r) return false;
-  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
-  const grammarTrivia = r._meta.grammarTrivia;
-  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
-}
-function makeSelectedRootLabelIndex(labels) {
-  const index = /* @__PURE__ */ Object.create(null);
-  for (let i = 0; i < labels.length; i++) {
-    if (index[labels[i]] === void 0) index[labels[i]] = i;
-  }
-  return index;
-}
-function growSpanEnd(span, input, end) {
-  if (span.endLine === void 0 || span.endColumn === void 0) {
-    return { start: span.start, end };
-  }
-  let line = span.endLine;
-  let column = span.endColumn;
-  for (let i = span.end; i < end; i++) {
-    if (input.charCodeAt(i) === 10) {
-      line++;
-      column = 1;
-    } else {
-      column++;
-    }
-  }
-  return { ...span, end, endLine: line, endColumn: column };
-}
-function runOnce(entry, input, options) {
-  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
-    throw new TypeError(
-      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
-    );
-  }
-  const rootTriviaSelection = options.rootTrivia?.select;
-  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
-  const selectedRootLog = captureRootTrivia ? [] : void 0;
-  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
-  const errors = [];
-  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
-  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
-  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
-  if (captureRootTrivia && triviaKindLabels === void 0) {
-    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
-  }
-  if (captureRootTrivia) {
-    for (const label2 of rootTriviaSelection) {
-      if (!triviaKindLabels.includes(label2)) {
-        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
-      }
-    }
-  }
-  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
-    throw new TypeError(
-      "run(): rootTrivia.select requires classifiedTrivia() at the root."
-    );
-  }
-  const stamped = entry;
-  assertHostModeCompatible(
-    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
-    options.build,
-    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
-  );
-  const ctx = createParseContext();
-  if (captureRootTrivia) {
-    ctx._rootTriviaLog = selectedRootLog;
-    ctx._rootTriviaKindIndex = selectedRootLabelIndex;
-    ctx._rootTriviaStrictScopes = true;
-  }
-  ctx._errors = errors;
-  ctx.build = options.build;
-  ctx.state = options.state;
-  if (grammarTrivia !== void 0) ctx.trivia = grammarTrivia;
-  if (triviaKindLabels) ctx.triviaKindLabels = triviaKindLabels;
-  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
-  if (options.triviaCaptureMask !== void 0) ctx._triviaCaptureMask = options.triviaCaptureMask;
-  if (options.tolerant) {
-    ctx._tolerant = true;
-    ctx._rec = REC;
-  }
-  if (options.instrumentation !== void 0) {
-    ctx._grammarCoverage = options.instrumentation._grammarCoverage;
-    ctx._grammarTrace = options.instrumentation._grammarTrace;
-  }
-  const r = invoke(entry, input, 0, ctx);
-  const value = r.ok ? r.value : void 0;
-  let span = r.span ?? { start: 0, end: 0 };
-  const expected = r.ok ? [] : r.expected ?? [];
-  let unconsumedFrom = null;
-  if (r.ok) {
-    let pos = span.end;
-    const tail = options.trivia ?? ambientTriviaFromRunnable(entry);
-    if (tail !== void 0 && pos < input.length) {
-      const t = invoke(tail, input, pos, createParseContext());
-      if (t.ok && t.span.end > pos) {
-        span = growSpanEnd(span, input, t.span.end);
-        pos = t.span.end;
-      }
-    }
-    unconsumedFrom = pos < input.length ? pos : null;
-  }
-  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
-    r.ok,
-    value,
-    span,
-    expected,
-    errors,
-    {
-      rows: selectedRootLog,
-      select: rootTriviaSelection,
-      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
-    },
-    unconsumedFrom
-  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
-}
-function run(entry, input, options = {}) {
-  return runOnce(entry, input, options);
-}
-
-// src/combinators/completions.ts
-function completionsAt(target, input, offset, options = {}) {
-  const probe = { offset, best: null };
-  const ctx = createParseContext();
-  ctx._probe = probe;
-  if (options.tolerant) {
-    ctx._tolerant = true;
-    ctx._rec = REC;
-  }
-  const sliced = input.slice(0, offset);
-  const result = "parseWithContext" in target ? target.parseWithContext(sliced, ctx, 0) : target.parse(sliced, 0, ctx);
-  if (result.ok) return options.tolerant ? probe.best?.expected ?? [] : [];
-  const best = deeperFail(probe.best, result);
-  return best?.expected ?? [];
-}
-function deeperFail(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  return a.span.start >= b.span.start ? a : b;
-}
-
-// src/regex/classes.ts
-var META = new Set("()[]{}*+?|^$.".split(""));
-
-// src/table/ops.ts
-var OP_LIT = 1;
-var OP_RX = 2;
-var OP_SEQ = 3;
-var OP_SEQV = 4;
-var OP_CHOICE = 5;
-var OP_REP = 6;
-var OP_REPV = 7;
-var OP_OPT = 8;
-var OP_XFORM = 9;
-var OP_NODE = 10;
-var OP_RULE = 11;
-var OP_GATE = 12;
-var OP_NOT = 13;
-var OP_PEEK = 14;
-var OP_LEAF = 15;
-var OP_EMPTY = 16;
-var OP_LIT_TRACK = 17;
-var OP_RX_TRACK = 18;
-var OP_NODE_TRACK = 19;
-var OP_SCOPE = 20;
-var OP_EXPECT = 21;
-var OP_SEQX = 22;
-var OP_SCAN = 23;
-var OP_FIELD = 24;
-var OP_LIT_CI = 27;
-var OP_LIT_CI_TRACK = 28;
-var OP_TOKEN = 29;
-var OP_SCOPE_CAP = 30;
-var OP_WITHCTX = 31;
-var OP_GUARD = 32;
-var OP_ADJ = 33;
-var OP_GREEDY = 34;
-var OP_REJECT = 35;
-var OP_ARMGATE = 36;
-var OP_LIVE = 37;
-var OP_ATTEMPT = 38;
-var OP_LABEL = 39;
-var OP_COV = 40;
-var OP_SCOPE_PLAIN = 41;
-var OP_DISPATCH = 25;
-var OP_ROUTED = 26;
-var OP_NAMES = {
-  [OP_LIT]: "LIT",
-  [OP_RX]: "RX",
-  [OP_SEQ]: "SEQ",
-  [OP_SEQV]: "SEQV",
-  [OP_CHOICE]: "CHOICE",
-  [OP_REP]: "REP",
-  [OP_REPV]: "REPV",
-  [OP_OPT]: "OPT",
-  [OP_XFORM]: "XFORM",
-  [OP_NODE]: "NODE",
-  [OP_RULE]: "RULE",
-  [OP_GATE]: "GATE",
-  [OP_NOT]: "NOT",
-  [OP_PEEK]: "PEEK",
-  [OP_LEAF]: "LEAF",
-  [OP_EMPTY]: "EMPTY",
-  [OP_LIT_TRACK]: "LIT_TRACK",
-  [OP_RX_TRACK]: "RX_TRACK",
-  [OP_NODE_TRACK]: "NODE_TRACK",
-  [OP_SCOPE]: "SCOPE",
-  [OP_EXPECT]: "EXPECT",
-  [OP_SEQX]: "SEQX",
-  [OP_SCAN]: "SCAN",
-  [OP_FIELD]: "FIELD",
-  [OP_LIT_CI]: "LIT_CI",
-  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
-  [OP_DISPATCH]: "DISPATCH",
-  [OP_ROUTED]: "ROUTED",
-  [OP_TOKEN]: "TOKEN",
-  [OP_SCOPE_CAP]: "SCOPE_CAP",
-  [OP_WITHCTX]: "WITHCTX",
-  [OP_GUARD]: "GUARD",
-  [OP_ADJ]: "ADJ",
-  [OP_GREEDY]: "GREEDY",
-  [OP_REJECT]: "REJECT",
-  [OP_ARMGATE]: "ARMGATE",
-  [OP_LIVE]: "LIVE",
-  [OP_ATTEMPT]: "ATTEMPT",
-  [OP_LABEL]: "LABEL",
-  [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN"
-};
-
-// src/table/scan-shapes.ts
-var META2 = new Set("()[]{}*+?|^$.".split(""));
-
-// src/table/assemble.ts
-var EMIT_ENABLED = globalThis.process?.env?.PM_TABLE_EMIT !== "0";
-var EMPTY_TL = Object.freeze([]);
-var EMPTY_SENTS = Object.freeze([]);
-
-// src/analysis/duplication.ts
-var WORD_RE_SRC = "-?[A-Za-z][A-Za-z0-9_-]*";
-var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
-
-// src/compiler/linker.ts
-function normalizeCstCollapse(collapse) {
-  if (collapse === true) return () => true;
-  if (Array.isArray(collapse)) {
-    const types = new Set(collapse);
-    return (type) => types.has(type);
-  }
-  return typeof collapse === "function" ? collapse : void 0;
-}
-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, _tags) {
-  if (typeof typeOrOptions === "string") {
-    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
-  }
-  const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  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;
-}
-cstBuildHost._parsemanCstOutput = true;
-function fusedHostModeOf(registry) {
-  const m = registry[FUSED_HOST_MODE];
-  return m === "cst" ? "cst" : "ast";
-}
-function fusedHostElidedOf(registry) {
-  return registry[FUSED_HOST_ELIDED] === true;
-}
-
-// src/cst/relative-spans.ts
-function relativizeCST(node2, parentBase = 0) {
-  const span = { start: node2.span.start - parentBase, end: node2.span.end - parentBase };
-  if (node2.children) {
-    const base = node2.span.start;
-    return { ...node2, span, children: node2.children.map((c) => relativizeCST(c, base)) };
-  }
-  return { ...node2, span };
-}
-function absolutizeCST(node2, parentBase = 0) {
-  const start = parentBase + node2.span.start;
-  const span = { start, end: parentBase + node2.span.end };
-  if (node2.children) {
-    return { ...node2, span, children: node2.children.map((c) => absolutizeCST(c, start)) };
-  }
-  return { ...node2, span };
-}
-function absoluteSpanCST(root, path) {
-  let base = 0;
-  let node2 = root;
-  for (const idx of path) {
-    base += node2.span.start;
-    const child = node2.children?.[idx];
-    if (!child) throw new RangeError(`absoluteSpanCST: no child ${idx} on path ${path.join(".")}`);
-    node2 = child;
-  }
-  return { start: base + node2.span.start, end: base + node2.span.end };
-}
-
-// src/functional/doc.ts
-function mkCtx(rawState, build, tolerant) {
-  const state = rawState ?? void 0;
-  return tolerant ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] } : { trackLines: false, state, build };
-}
-function asRuleFn(entry) {
-  return typeof entry === "function" ? entry : (input, pos, ctx) => entry.parse(input, pos, ctx);
-}
-function defOf(entry) {
-  return typeof entry === "object" && entry !== null && "_def" in entry ? entry._def : void 0;
-}
-function literalTextOf(parser2, depth = 0) {
-  const def = defOf(parser2);
-  if (!def || depth > 24) return null;
-  const d = def;
-  switch (d.tag) {
-    case "literal":
-      return d.caseInsensitive ? null : d.value;
-    case "lazy": {
-      const thunk = d.thunk;
-      try {
-        return typeof thunk === "function" ? literalTextOf(thunk(), depth + 1) : null;
-      } catch {
-        return null;
-      }
-    }
-    case "node":
-    case "transform":
-    case "attempt":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-      return literalTextOf(d.parser, depth + 1);
-    default:
-      return null;
-  }
-}
-function producesRepetition(def, depth = 0) {
-  if (!def || depth > 24) return null;
-  const d = def;
-  switch (d.tag) {
-    case "sepBy": {
-      if (d.keepSeparators) return null;
-      const text = literalTextOf(d.separator);
-      return text === null || text.length === 0 ? null : { kind: "sep", text };
-    }
-    case "many":
-    case "oneOrMore":
-      return { kind: "bare" };
-    // Rule entries and `ref`s wrap their body in a `lazy` thunk — resolve it. The
-    // `depth` cap bounds any self-referential cycle (a repetition, if present, is
-    // found shallowly before recursion goes deep).
-    case "lazy": {
-      const thunk = d.thunk;
-      let inner;
-      try {
-        inner = typeof thunk === "function" ? thunk() : void 0;
-      } catch {
-        return null;
-      }
-      return producesRepetition(inner?._def, depth + 1);
-    }
-    // Transparent wrappers — look through to the inner parser.
-    case "node":
-    case "transform":
-    case "attempt":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-    case "optional":
-      return producesRepetition(defOf(d.parser), depth + 1);
-    // A bracketed/anchored list is a sequence whose element run is a repetition.
-    case "sequence": {
-      for (const p of d.parsers) {
-        const rep = producesRepetition(defOf(p), depth + 1);
-        if (rep) return rep;
-      }
-      return null;
-    }
-    default:
-      return null;
-  }
-}
-var REENTRY_MAX_SPAN_FRACTION = 0.5;
-function isNode(x) {
-  return typeof x === "object" && x !== null && x._tag === "node";
-}
-function findContaining(node2, nodeAbsStart, pos, path = []) {
-  for (let i = 0; i < node2.children.length; i++) {
-    const child = node2.children[i];
-    if (!isNode(child)) continue;
-    const childAbsStart = nodeAbsStart + child.span.start;
-    const childAbsEnd = nodeAbsStart + child.span.end;
-    if (childAbsStart <= pos && pos < childAbsEnd) {
-      const inner = findContaining(child, childAbsStart, pos, [...path, i]);
-      return inner ?? { node: child, path: [...path, i] };
-    }
-  }
-  return null;
-}
-function ancestorsAt(root, path) {
-  const ancestors = [root];
-  let cur = root;
-  for (const idx of path.slice(0, -1)) {
-    const child = cur.children[idx];
-    if (!child || !isNode(child)) break;
-    ancestors.push(child);
-    cur = child;
-  }
-  return ancestors;
-}
-function replaceAtPath(rebuild, root, path, newNode) {
-  if (path.length === 0) return newNode;
-  const [idx, ...rest] = path;
-  const newChildren = [...root.children];
-  newChildren[idx] = rest.length === 0 ? newNode : replaceAtPath(rebuild, root.children[idx], rest, newNode);
-  return rebuild(root, newChildren);
-}
-function defaultRebuild(node2, children) {
-  return { ...node2, children };
-}
-function shiftRelStart(child, delta) {
-  const c = child;
-  return { ...c, span: { start: c.span.start + delta, end: c.span.end + delta } };
-}
-function graftRelative(root, path, newNode, delta) {
-  if (path.length === 0) return newNode;
-  const [idx, ...rest] = path;
-  const oldChildren = root.children;
-  const newChildren = oldChildren.map((child, i) => {
-    if (i < idx) return child;
-    if (i === idx) {
-      return rest.length === 0 ? newNode : graftRelative(child, rest, newNode, delta);
-    }
-    return shiftRelStart(child, delta);
-  });
-  return {
-    ...root,
-    span: { start: root.span.start, end: root.span.end + delta },
-    children: newChildren
-  };
-}
-function parseMiddle(input, reStart, reEnd, cStart, ruleFn, separator, startsAtElement, build, tolerant) {
-  const ctx = mkCtx(null, build, tolerant);
-  const out = [];
-  let pos = reStart;
-  let guard = 0;
-  let expectElement = separator === null ? true : startsAtElement;
-  while (pos < reEnd) {
-    if (++guard > reEnd - reStart + 2) return null;
-    if (separator !== null && !expectElement) {
-      if (pos + separator.length > reEnd || !input.startsWith(separator, pos)) return null;
-      pos += separator.length;
-      expectElement = true;
-      continue;
-    }
-    let r;
-    try {
-      r = ruleFn(input, pos, ctx);
-    } catch {
-      return null;
-    }
-    if (!r.ok || r.span.end <= pos || r.span.end > reEnd) return null;
-    out.push(relativizeCST(r.value, cStart));
-    pos = r.span.end;
-    if (separator !== null) expectElement = false;
-  }
-  return pos === reEnd && expectElement ? out : null;
-}
-function tryListSplice(root, path, C, cStart, newInput, from, to, delta, rep, registry, build, tolerant) {
-  const kids = C.children;
-  if (kids.length === 0) return null;
-  let h = 0;
-  while (h < kids.length && cStart + kids[h].span.end <= from) h++;
-  let t = kids.length;
-  while (t > h && cStart + kids[t - 1].span.start >= to) t--;
-  while (t < kids.length && kids[t]._tag !== "node") t++;
-  if (t >= kids.length) return null;
-  for (let i = t; i < kids.length; i++) {
-    if (kids[i]._tag === "node" && kids[i].state != null) return null;
-  }
-  let elemType;
-  let elemCount = 0;
-  for (const k of kids) {
-    if (k._tag !== "node") continue;
-    elemCount++;
-    if (elemType === void 0) elemType = k.type;
-    else if (k.type !== elemType) return null;
-  }
-  if (elemType === void 0 || elemCount < 2) return null;
-  const ruleFn = registry[elemType];
-  if (!ruleFn) return null;
-  const separator = rep.kind === "sep" ? rep.text : null;
-  const first = kids[0];
-  const last = kids[kids.length - 1];
-  if (first._tag === "leaf" && first.value !== separator && from < cStart + first.span.end) return null;
-  if (last._tag === "leaf" && last.value !== separator && to > cStart + last.span.start) return null;
-  const reStart = h > 0 ? cStart + kids[h - 1].span.end : cStart;
-  const reEnd = cStart + kids[t].span.start + delta;
-  if (reEnd < reStart) return null;
-  const startsAtElement = !(h > 0 && kids[h - 1]._tag === "node");
-  const middle = parseMiddle(newInput, reStart, reEnd, cStart, ruleFn, separator, startsAtElement, build, tolerant);
-  if (!middle) return null;
-  if (reEnd < newInput.length) {
-    for (const sentinel of [" ", "\uFFFF"]) {
-      if (newInput[reEnd] === sentinel) continue;
-      const probed = newInput.slice(0, reEnd) + sentinel.repeat(newInput.length - reEnd);
-      const probe = parseMiddle(probed, reStart, reEnd, cStart, ruleFn, separator, startsAtElement, build, tolerant);
-      if (!probe || probe.length !== middle.length) return null;
-      for (let i = 0; i < middle.length; i++) if (!structurallyEqual(probe[i], middle[i])) return null;
-    }
-  }
-  const head = kids.slice(0, h);
-  const tail = kids.slice(t).map((k) => shiftRelStart(k, delta));
-  const newC = {
-    ...C,
-    span: { start: C.span.start, end: C.span.end + delta },
-    children: [...head, ...middle, ...tail]
-  };
-  return graftRelative(root, path, newC, delta);
-}
-function structurallyEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-  const at = a._tag;
-  const bt = b._tag;
-  if (at !== bt) return false;
-  const as = a.span;
-  const bs = b.span;
-  if (as || bs) {
-    if (!as || !bs || as.start !== bs.start || as.end !== bs.end) return false;
-  }
-  if (at === "leaf" || at === "trivia") {
-    return a.value === b.value;
-  }
-  if (at === "parseError") {
-    const ae = a.expected ?? [];
-    const be = b.expected ?? [];
-    return ae.length === be.length && ae.every((x, i) => x === be[i]);
-  }
-  if (a.type !== b.type) return false;
-  const ac = a.children;
-  const bc = b.children;
-  if (ac || bc) {
-    if (!ac || !bc || ac.length !== bc.length) return false;
-    for (let i = 0; i < ac.length; i++) if (!structurallyEqual(ac[i], bc[i])) return false;
-  }
-  return true;
-}
-function boundaryIsSafe(ruleFn, newInput, start, boundary, state, build, produced, tolerant) {
-  if (!produced.ok) return false;
-  if (boundary >= newInput.length) return true;
-  for (const sentinel of [" ", "\uFFFF"]) {
-    if (newInput[boundary] === sentinel) continue;
-    const probed = newInput.slice(0, boundary) + sentinel.repeat(newInput.length - boundary);
-    const ctx = mkCtx(state, build, tolerant);
-    let r;
-    try {
-      r = ruleFn(probed, start, ctx);
-    } catch {
-      return false;
-    }
-    if (!r.ok || r.span.end !== produced.span.end) return false;
-    if (!structurallyEqual(r.value, produced.value)) return false;
-  }
-  return true;
-}
-var ParseDocImpl = class _ParseDocImpl {
-  _registry;
-  /** Registry entries normalized to callable parse functions (memoized once). */
-  _fns;
-  /**
-   * Rule names the grammar proves are genuine repetitions — the ONLY splice-safe
-   * types — mapped to the repetition shape (and, for a `sepBy`, the separator text
-   * its construction pins). A rule whose separator isn't recoverable is absent.
-   */
-  _reps;
-  _rootRule;
-  _opts;
-  /**
-   * The tree, held in whichever coordinate system it arrived in. A fresh parse
-   * arrives ABSOLUTE (`_abs` set); an incremental graft arrives PARENT-RELATIVE
-   * (`_rel` set). The public `tree` is always the RELATIVE form (so untouched
-   * subtrees stay shared by identity across edits and reads are O(1)); it's
-   * materialized from `_abs` once, on demand, and memoized. `undefined` = not yet
-   * computed; `null` = failed parse. A fresh parse that's never edited nor
-   * tree-read pays no conversion — important for the full-reparse fallback path.
-   */
-  _abs;
-  _rel;
-  errors;
-  unconsumedFrom;
-  input;
-  constructor(registry, rootRule, opts, trees, errors, unconsumedFrom, input) {
-    this._registry = registry;
-    this._fns = {};
-    this._reps = /* @__PURE__ */ new Map();
-    for (const [name, entry] of Object.entries(registry)) {
-      this._fns[name] = asRuleFn(entry);
-      const rep = producesRepetition(defOf(entry));
-      if (rep) this._reps.set(name, rep);
-    }
-    this._rootRule = rootRule;
-    this._opts = opts;
-    this._abs = trees.abs;
-    this._rel = trees.rel;
-    this.errors = errors;
-    this.unconsumedFrom = unconsumedFrom;
-    this.input = input;
-  }
-  /**
-   * The parse tree with PARENT-RELATIVE spans — a node's `span` is relative to
-   * its parent's start (root base 0). This is the shareable representation:
-   * untouched subtrees keep the same identity across `.edit()`s, and reading the
-   * tree after a length-changing edit is O(1) (no offset rewrite). For absolute
-   * positions use the O(depth) cursor `spanAt(path)`, or `absolutizeCST(tree)` to
-   * materialize the whole absolute tree. (A fresh non-incremental `node().parse()`
-   * result is unchanged — still absolute.)
-   */
-  get tree() {
-    if (this._rel === void 0) {
-      this._rel = this._abs ? relativizeCST(this._abs, 0) : null;
-    }
-    return this._rel;
-  }
-  spanAt(path) {
-    const rel = this.tree;
-    if (!rel) throw new Error("spanAt on a failed parse (tree is null)");
-    return absoluteSpanCST(rel, path);
-  }
-  /**
-   * Wrap a reused (grafted/spliced) RELATIVE tree, recomputing `errors` and
-   * `unconsumedFrom` from it so both stay consistent with the tree across the
-   * edit (the flat errors are recovered errors embedded in the reused subtrees;
-   * unconsumedFrom re-derives trailing junk over the new input).
-   */
-  wrapReuse(newTree, newInput) {
-    const trivia2 = triviaOf(this._registry[this._rootRule], this._opts);
-    const end = newTree.span.end;
-    const errors = collectEmbeddedErrors(newTree, 0, []);
-    const unconsumedFrom = unconsumedAfter(end, newInput, trivia2);
-    return new _ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: newTree }, errors, unconsumedFrom, newInput);
-  }
-  edit(from, to, replacement) {
-    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to);
-    const reparse = () => parseDoc(this._registry, this._rootRule, newInput, this._opts);
-    const root = this.tree;
-    if (!root) return reparse();
-    const delta = replacement.length - (to - from);
-    const found = findContaining(root, 0, from) ?? { node: root, path: [] };
-    const ancestors = ancestorsAt(root, found.path);
-    const candidates = [found];
-    const pathCopy = [...found.path];
-    for (let i = ancestors.length - 2; i >= 0; i--) {
-      pathCopy.pop();
-      candidates.push({ node: ancestors[i + 1], path: [...pathCopy] });
-    }
-    const rebuild = this._opts.rebuild ?? defaultRebuild;
-    for (const { node: node2, path } of candidates) {
-      const { start: absStart, end: absEnd } = absoluteSpanCST(root, path);
-      if (absEnd - absStart > this.input.length * REENTRY_MAX_SPAN_FRACTION) break;
-      const ruleFn = this._fns[node2.type];
-      if (!ruleFn) continue;
-      if (!(absStart <= from && to <= absEnd)) continue;
-      const ctx = mkCtx(node2.state, this._opts.build, !!this._opts.tolerant);
-      const r = ruleFn(newInput, absStart, ctx);
-      if (!r.ok) continue;
-      if (r.span.end !== absEnd + delta) continue;
-      if (!boundaryIsSafe(ruleFn, newInput, absStart, absEnd + delta, node2.state, this._opts.build, r, !!this._opts.tolerant)) {
-        continue;
-      }
-      const parentBase = absStart - node2.span.start;
-      const newRel = relativizeCST(r.value, parentBase);
-      if (delta === 0) {
-        const newTree2 = replaceAtPath(rebuild, root, path, newRel);
-        return this.wrapReuse(newTree2, newInput);
-      }
-      if (this._opts.rebuild) return reparse();
-      const newTree = graftRelative(root, path, newRel, delta);
-      return this.wrapReuse(newTree, newInput);
-    }
-    if (this._opts.structuralReuse && delta !== 0 && !this._opts.rebuild) {
-      const spliceCandidates = [...candidates, { node: root, path: [] }];
-      for (const { node: node2, path } of spliceCandidates) {
-        const rep = this._reps.get(node2.type);
-        if (!rep) continue;
-        const { start: cStart, end: cEnd } = absoluteSpanCST(root, path);
-        if (!(cStart <= from && to <= cEnd)) continue;
-        const spliced = tryListSplice(root, path, node2, cStart, newInput, from, to, delta, rep, this._fns, this._opts.build, !!this._opts.tolerant);
-        if (spliced) return this.wrapReuse(spliced, newInput);
-      }
-    }
-    return reparse();
-  }
-};
-function triviaOf(entry, opts) {
-  if (opts.trivia) return opts.trivia;
-  if (entry === void 0 || typeof entry === "function") return void 0;
-  const meta = entry._meta;
-  return meta ? meta.grammarTrivia : void 0;
-}
-function unconsumedAfter(end, input, trivia2) {
-  let pos = end;
-  if (trivia2 && pos < input.length) {
-    const t = trivia2.parse(input, pos, createParseContext());
-    if (t.ok && t.span.end > pos) pos = t.span.end;
-  }
-  return pos < input.length ? pos : null;
-}
-function collectEmbeddedErrors(node2, base, out) {
-  const c = node2;
-  if (!c || typeof c !== "object" || !c.span) return out;
-  const start = base + c.span.start;
-  if (c._tag === "parseError") {
-    out.push({ _tag: "parseError", span: { start, end: base + c.span.end }, expected: c.expected ?? [] });
-    return out;
-  }
-  if (Array.isArray(c.children)) for (const k of c.children) collectEmbeddedErrors(k, start, out);
-  return out;
-}
-function parseDoc(registry, rootRule, input, opts = {}) {
-  const entry = registry[rootRule];
-  if (!entry) throw new Error(`No rule '${rootRule}' in registry`);
-  assertHostModeCompatible(fusedHostModeOf(registry), opts.build, fusedHostElidedOf(registry));
-  const ctx = mkCtx(opts.state, opts.build, !!opts.tolerant);
-  const r = asRuleFn(entry)(input, 0, ctx);
-  if (r.ok) {
-    const errors = ctx._errors ? [...ctx._errors] : [];
-    const unconsumedFrom = unconsumedAfter(r.span.end, input, triviaOf(entry, opts));
-    return new ParseDocImpl(registry, rootRule, opts, { abs: r.value }, errors, unconsumedFrom, input);
-  }
-  const fail = { _tag: "parseError", span: r.span, expected: r.expected };
-  return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input);
-}
-
-// src/language-service/index.ts
-var errorMessage = (expected) => expected.length ? `Unexpected input; expected ${expected.join(" or ")}` : "Unexpected input";
-function visitTree(root, enter) {
-  const go = (node2) => {
-    enter(node2);
-    const children = node2.children;
-    if (Array.isArray(children)) for (const child of children) go(child);
-  };
-  go(root);
-}
-function mergeDiagnostics(tree, flat, unconsumedFrom, inputLength, config) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (d) => {
-    const key = `${d.severity}|${d.span.start}|${d.span.end}|${d.message}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    out.push(d);
-  };
-  if (tree) for (const d of diagnoseTree(tree, config)) add(d);
-  for (const e of flat) add({ severity: "error", message: errorMessage(e.expected), span: e.span });
-  if (unconsumedFrom !== null) {
-    add({ severity: "error", message: "Unexpected input", span: { start: unconsumedFrom, end: inputLength } });
-  }
-  return out;
-}
-function diagnoseTree(root, config) {
-  const out = [];
-  const rules2 = config.diagnostics;
-  visitTree(root, (node2) => {
-    if (node2._tag === "parseError") {
-      out.push({ severity: "error", message: errorMessage(node2.expected ?? []), span: node2.span });
-      return;
-    }
-    const h = rules2 && node2.type !== void 0 ? rules2[node2.type] : void 0;
-    if (h) {
-      const d = h(node2);
-      if (d) out.push(...Array.isArray(d) ? d : [d]);
-    }
-  });
-  return out;
-}
-function languageService(grammar, config = {}) {
-  const build = cstBuildHost();
-  const asReg = typeof grammar === "object" && grammar !== null && "rules" in grammar;
-  const registry = asReg ? grammar.rules : void 0;
-  const root = asReg ? grammar.root : void 0;
-  const entry = asReg ? registry[root] : grammar;
-  const trivia2 = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
-  const parseTolerant = (src) => run(entry, src, { tolerant: true, build, ...trivia2 !== void 0 ? { trivia: trivia2 } : {} });
-  const complete = (input, offset, treeForCursor) => {
-    const expected = completionsAt(entry, input, offset, { tolerant: true });
-    const rule = ruleAtCursor(treeForCursor, offset);
-    const handler = rule !== null ? config.complete?.[rule] : void 0;
-    if (handler) return handler({ rule, expected, offset });
-    return expected.map((label2) => ({ label: label2 }));
-  };
-  return {
-    parse(src, opts) {
-      return run(entry, src, { tolerant: opts?.tolerant ?? true, build });
-    },
-    diagnostics(src) {
-      const r = parseTolerant(src);
-      const tree = r.value && typeof r.value === "object" ? r.value : null;
-      return mergeDiagnostics(tree, r.errors, r.unconsumedFrom, src.length, config);
-    },
-    completionsAt(src, offset) {
-      return complete(src, offset, parseTolerant(src.slice(0, offset)).value);
-    },
-    openDocument(src) {
-      if (!registry || root === void 0) {
-        throw new Error("openDocument requires languageService({ rules, root }, config) \u2014 a rules() registry, not a single entry");
-      }
-      const host = cstBuildHost();
-      const make = (doc) => {
-        const abs = doc.tree ? absolutizeCST(doc.tree) : null;
-        return {
-          get tree() {
-            return abs;
-          },
-          edit: (from, to, replacement) => make(doc.edit(from, to, replacement)),
-          // Same unified merge as the stateless path: embedded parseError nodes +
-          // lint, the flat recovery errors the doc collected, and a trailing-junk
-          // sentinel — so a live editor document surfaces missing-closers and junk.
-          diagnostics: () => mergeDiagnostics(abs, doc.errors, doc.unconsumedFrom, doc.input.length, config),
-          completionsAt: (offset) => complete(doc.input, offset, abs)
-        };
-      };
-      return make(parseDoc(registry, root, src, { tolerant: true, structuralReuse: true, build: host }));
-    }
-  };
-}
-function ruleAtCursor(root, offset) {
-  if (!root || typeof root !== "object") return null;
-  let best = null;
-  visitTree(root, (node2) => {
-    const s = node2.span;
-    if (s && s.start <= offset && offset <= s.end && node2.type !== void 0) best = node2.type;
-  });
-  return best;
-}
-//# sourceMappingURL=index.cjs.map