parseman 0.25.0 → 0.26.0

package/dist/language-service/index.cjs

@@ -0,0 +1,776 @@
+"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/cst/capture-buffer.ts
+function cstCaptureActive(ctx) {
+  return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
+}
+function pushCstChild(ctx, built, rawEntry) {
+  const b = ctx._cstBuf;
+  if (b) {
+    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(rawEntry);
+    else if (b.rawSingle !== void 0) {
+      b.raw = [b.rawSingle, rawEntry];
+      b.rawSingle = void 0;
+    } else b.rawSingle = rawEntry;
+    return;
+  }
+  if (ctx._cstChildren) ctx._cstChildren.push(built);
+  else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
+  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry);
+}
+
+// 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,
+    _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._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._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 error = { _tag: "parseError", span: { start: from, end: scanPos }, 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/functional/run.ts
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function run(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 triviaLog = [];
+  const errors = [];
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
+  const ctx = {
+    trackLines: false,
+    _triviaLog: triviaLog,
+    _errors: errors,
+    build: options.build,
+    state: options.state,
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
+    ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
+    ...options.tolerant ? { _tolerant: true, _rec: REC } : {}
+  };
+  const r = invoke(entry, input, 0, ctx);
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = r.span?.end ?? 0;
+    if (options.trivia && pos < input.length) {
+      const t = invoke(options.trivia, input, pos, { trackLines: false });
+      if (t.ok && t.span.end > pos) pos = t.span.end;
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
+  }
+  return {
+    ok: r.ok,
+    value: r.ok ? r.value : void 0,
+    span: r.span ?? { start: 0, end: 0 },
+    expected: r.ok ? [] : r.expected ?? [],
+    errors,
+    triviaLog,
+    unconsumedFrom
+  };
+}
+
+// src/combinators/completions.ts
+function completionsAt(target, input, offset, options = {}) {
+  const probe = { offset, best: null };
+  const ctx = { trackLines: false, _probe: probe, ...options.tolerant ? { _tolerant: true, _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/compiler/scannable-run.ts
+var META = new Set("()[]{}*+?|^$.".split(""));
+
+// src/compiler/trivia-fast-path.ts
+var CAP_RECORD = [
+  `  if (_cap && _e > _pos) {`,
+  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
+  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+  `  }`
+].join("\n");
+
+// 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) {
+  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
+}
+function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+  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);
+  if (collapse) host._parsemanCstCollapse = collapse;
+  return host;
+}
+
+// src/cst/walk.ts
+function walk(root, visitor, ctx = void 0) {
+  const go = (node2, parent) => {
+    const descend = visitor.enter ? visitor.enter(node2, parent, ctx) : void 0;
+    const children = node2.children;
+    if (descend !== false && Array.isArray(children)) {
+      for (const child of children) go(child, node2);
+    }
+    visitor.leave?.(node2, parent, ctx);
+  };
+  go(root, null);
+}
+
+// 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(state, build, tolerant) {
+  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 producesRepetition(def, depth = 0) {
+  if (!def || depth > 24) return false;
+  const d = def;
+  switch (d.tag) {
+    case "sepBy":
+    case "many":
+    case "oneOrMore":
+      return true;
+    // 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 false;
+      }
+      return producesRepetition(inner?._def, depth + 1);
+    }
+    // Transparent wrappers — look through to the inner parser.
+    case "node":
+    case "transform":
+    case "token":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "optional":
+      return producesRepetition(defOf(d.parser), depth + 1);
+    case "skip":
+      return producesRepetition(defOf(d.main), depth + 1);
+    // A bracketed/anchored list is a sequence whose element run is a repetition.
+    case "sequence":
+      return d.parsers.some((p) => producesRepetition(defOf(p), depth + 1));
+    default:
+      return false;
+  }
+}
+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, build, tolerant) {
+  const ctx = mkCtx(null, build, tolerant);
+  const out = [];
+  let pos = reStart;
+  let guard = 0;
+  while (pos < reEnd) {
+    if (++guard > reEnd - reStart + 2) return null;
+    if (separator && out.length > 0 && out[out.length - 1]._tag === "node") {
+      if (pos + separator.length > reEnd || !input.startsWith(separator, pos)) return null;
+      out.push({ _tag: "leaf", value: separator, span: { start: pos - cStart, end: pos + separator.length - cStart } });
+      pos += separator.length;
+      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;
+  }
+  return pos === reEnd ? out : null;
+}
+function tryListSplice(root, path, C, cStart, newInput, from, to, delta, 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++;
+  while (h > 0 && kids[h - 1]._tag === "node") 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;
+  let separator = null;
+  for (let i = 1; i < kids.length - 1; i++) {
+    if (kids[i - 1]._tag === "node" && kids[i + 1]._tag === "node") {
+      if (kids[i]._tag !== "leaf") return null;
+      const sep = kids[i].value ?? null;
+      if (separator === null) separator = sep;
+      else if (sep !== separator) return null;
+    }
+  }
+  if (separator === null) return 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 middle = parseMiddle(newInput, reStart, reEnd, cStart, ruleFn, separator, build, tolerant);
+  if (!middle) return null;
+  if (middle.length > 0) {
+    const last2 = middle[middle.length - 1];
+    if (!(last2._tag === "leaf" && last2.value === separator)) 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, 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. */
+  _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 Set();
+    for (const [name, entry] of Object.entries(registry)) {
+      this._fns[name] = asRuleFn(entry);
+      if (producesRepetition(defOf(entry))) this._reps.add(name);
+    }
+    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) {
+        if (!this._reps.has(node2.type)) 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, 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, { trackLines: false });
+    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`);
+  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 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;
+  walk(root, {
+    enter(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;
+  walk(root, {
+    enter(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