parseman 0.23.0 → 0.25.0

package/dist/index.cjs

@@ -22,7 +22,9 @@ var index_exports = {};
 __export(index_exports, {
   OffsetIndex: () => OffsetIndex,
   absoluteSpanAt: () => absoluteSpanAt,
+  absoluteSpanCST: () => absoluteSpanCST,
   absolutize: () => absolutize,
+  absolutizeCST: () => absolutizeCST,
   annotateSpan: () => annotateSpan,
   applyEdit: () => applyEdit,
   balanced: () => balanced,
@@ -67,6 +69,7 @@ __export(index_exports, {
   ref: () => ref,
   regex: () => regex,
   relativize: () => relativize,
+  relativizeCST: () => relativizeCST,
   rules: () => rules,
   run: () => run,
   scanTo: () => scanTo,
@@ -431,24 +434,35 @@ function literal(value, opts = {}) {
       { lo: firstUpper, hi: firstUpper }
     ] } : firstSet2;
   }
+  const expected = [JSON.stringify(value)];
+  const parse2 = !caseInsensitive && value.length === 1 ? (() => {
+    const code = value.charCodeAt(0);
+    return function parse3(input, pos, ctx) {
+      if (input.charCodeAt(pos) === code) {
+        const span = { start: pos, end: pos + 1 };
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+        return { ok: true, value, span };
+      }
+      return failAt(ctx, expected, pos);
+    };
+  })() : function parse3(input, pos, ctx) {
+    const end = pos + value.length;
+    if (end > input.length) {
+      return failAt(ctx, expected, pos);
+    }
+    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+      const span = { start: pos, end };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
+      return { ok: true, value: matchedValue, span };
+    }
+    return failAt(ctx, expected, pos);
+  };
   return {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
-    parse(input, pos, ctx) {
-      const end = pos + value.length;
-      if (end > input.length) {
-        return failAt(ctx, [JSON.stringify(value)], pos);
-      }
-      const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
-      if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
-        const span = { start: pos, end };
-        const leaf = { _tag: "leaf", value: matchedValue, span };
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
-        return { ok: true, value: matchedValue, span };
-      }
-      return failAt(ctx, [JSON.stringify(value)], pos);
-    }
+    parse: parse2
   };
 }
 
@@ -583,8 +597,7 @@ function regex(pattern, flags = "") {
         if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
         const value = input.slice(pos, scanEnd);
         const span2 = { start: pos, end: scanEnd };
-        const leaf2 = { _tag: "leaf", value, span: span2 };
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf2);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
         return { ok: true, value, span: span2 };
       }
       anchored.lastIndex = pos;
@@ -593,8 +606,7 @@ function regex(pattern, flags = "") {
         return failAt(ctx, [`/${source}/`], pos);
       }
       const span = { start: pos, end: pos + m[0].length };
-      const leaf = { _tag: "leaf", value: m[0], span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
       return { ok: true, value: m[0], span };
     }
   };
@@ -902,8 +914,7 @@ function keywords(words, opts = {}) {
       }
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
-      const leaf = { _tag: "leaf", value, span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
       return { ok: true, value, span };
     }
   };
@@ -1393,33 +1404,136 @@ function loopScanner(arms) {
 }
 function regexTriviaScanner(parser2) {
   if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
-  const ws = whitespaceSource(parser2._def.source);
-  if (ws) return ws;
-  return blockCommentSource(parser2._def.source) ? scanBlockComment : null;
+  const source = parser2._def.source;
+  return classRunSource(source) ?? altStarSource(source) ?? (blockCommentSource(source) ? scanBlockComment : null);
 }
-function whitespaceSource(source) {
-  const m = /^\[([ \\tnrf]+)\][*+]$/.exec(source);
-  if (!m) return null;
-  const chars = /* @__PURE__ */ new Set();
-  for (let i = 0; i < m[1].length; i++) {
-    const ch = m[1][i];
-    if (ch !== "\\") {
-      chars.add(ch.charCodeAt(0));
-      continue;
+function inRanges2(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    if (cp >= r[0] && cp <= r[1]) return true;
+  }
+  return false;
+}
+function classScanner(classBody) {
+  const ranges = parseClassRanges(classBody);
+  if (!ranges) return null;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
+}
+function lineCommentScanner(commentCode) {
+  return (input, cur) => {
+    if (input.charCodeAt(cur) !== commentCode) return cur;
+    let pos = cur + 1;
+    while (pos < input.length) {
+      const cc = input.charCodeAt(pos);
+      if (cc === 10 || cc === 13) break;
+      pos++;
     }
-    const esc = m[1][++i];
-    if (esc === "t") chars.add(9);
-    else if (esc === "n") chars.add(10);
-    else if (esc === "r") chars.add(13);
-    else if (esc === "f") chars.add(12);
-    else return null;
+    return pos;
+  };
+}
+function classRunSource(source) {
+  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
+  return m ? classScanner(m[1]) : null;
+}
+function classifyTriviaArm(arm) {
+  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
+  if (cls) {
+    const ranges = parseClassRanges(cls[1]);
+    return ranges ? { kind: "class", ranges } : null;
   }
+  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
+  if (lc) {
+    const marker = lc[1];
+    return { kind: "comment", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+  }
+  return null;
+}
+function armScanner(arm) {
+  if (arm.kind === "comment") return lineCommentScanner(arm.code);
+  const ranges = arm.ranges;
   return (input, cur) => {
     let pos = cur;
-    while (pos < input.length && chars.has(input.charCodeAt(pos))) pos++;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
     return pos;
   };
 }
+function fusedTriviaScanner(ranges, commentCodes) {
+  const c0 = commentCodes[0];
+  const single = commentCodes.length === 1;
+  return (input, cur) => {
+    let pos = cur;
+    const len = input.length;
+    for (; ; ) {
+      const c = input.charCodeAt(pos);
+      if (pos < len && inRanges2(c, ranges)) {
+        pos++;
+        continue;
+      }
+      if (single ? c === c0 : commentCodes.includes(c)) {
+        pos++;
+        while (pos < len) {
+          const cc = input.charCodeAt(pos);
+          if (cc === 10 || cc === 13) break;
+          pos++;
+        }
+        continue;
+      }
+      break;
+    }
+    return pos;
+  };
+}
+function splitTopLevelAlts(body) {
+  const arms = [];
+  let inClass = false;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") return null;
+    else if (c === "|") {
+      arms.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  arms.push(body.slice(start));
+  return arms;
+}
+function altStarSource(source) {
+  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
+  if (!m) return null;
+  const armSrcs = splitTopLevelAlts(m[1]);
+  if (!armSrcs || armSrcs.length < 2) return null;
+  const arms = [];
+  for (const src of armSrcs) {
+    const arm = classifyTriviaArm(src);
+    if (!arm) return null;
+    arms.push(arm);
+  }
+  const ranges = [];
+  const commentCodes = [];
+  for (const arm of arms) {
+    if (arm.kind === "class") ranges.push(...arm.ranges);
+    else commentCodes.push(arm.code);
+  }
+  if (commentCodes.some((code) => inRanges2(code, ranges))) {
+    return loopScanner(arms.map(armScanner));
+  }
+  if (commentCodes.length === 0) return armScanner({ kind: "class", ranges });
+  return fusedTriviaScanner(ranges, commentCodes);
+}
 function blockCommentSource(source) {
   return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
 }
@@ -1773,6 +1887,7 @@ function markUnusedValues(root) {
 }
 
 // src/combinators/parser.ts
+var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
   ;
   r._ruleName = key;
@@ -1817,6 +1932,11 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
+  Object.defineProperty(cache, RULE_ORDER, {
+    value: Object.keys(definitions),
+    enumerable: false,
+    configurable: true
+  });
   return cache;
 }
 
@@ -6364,17 +6484,159 @@ function manyRecover(item, until) {
   return many(tolerantElement(item, until, until));
 }
 
+// src/cst/relative-spans.ts
+function relativize(node2, parentBase = 0) {
+  return {
+    start: node2.start - parentBase,
+    end: node2.end - parentBase,
+    children: node2.children.map((c) => relativize(c, node2.start))
+  };
+}
+function absolutize(node2, parentBase = 0) {
+  const start = parentBase + node2.start;
+  return {
+    start,
+    end: parentBase + node2.end,
+    children: node2.children.map((c) => absolutize(c, start))
+  };
+}
+function absoluteSpanAt(root, path) {
+  let base = 0;
+  let node2 = root;
+  for (const idx of path) {
+    base += node2.start;
+    const child = node2.children[idx];
+    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join(".")}`);
+    node2 = child;
+  }
+  return { start: base + node2.start, end: base + node2.end };
+}
+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 };
+}
+function shiftAbsolute(node2, at, delta) {
+  const s = node2.start >= at ? node2.start + delta : node2.start;
+  const e = node2.end >= at ? node2.end + delta : node2.end;
+  return {
+    start: s,
+    end: e,
+    children: node2.children.map((c) => shiftAbsolute(c, at, delta))
+  };
+}
+function applyEdit(root, at, delta, stats) {
+  return editNode(root, at, delta, 0, 0, stats);
+}
+function editNode(node2, at, delta, parentBase, parentShift, stats) {
+  const absStart = parentBase + node2.start;
+  const absEnd = parentBase + node2.end;
+  if (absEnd < at) return node2;
+  const startShifts = absStart >= at;
+  if (startShifts && parentShift === delta) return node2;
+  if (stats) stats.allocated++;
+  const newAbsStart = startShifts ? absStart + delta : absStart;
+  const newAbsEnd = absEnd + delta;
+  const newParentBase = parentBase + parentShift;
+  const newStart = newAbsStart - newParentBase;
+  const newEnd = newAbsEnd - newParentBase;
+  const ownShift = newAbsStart - absStart;
+  let changed = false;
+  const newChildren = [];
+  for (const c of node2.children) {
+    const nc = editNode(c, at, delta, absStart, ownShift, stats);
+    if (nc !== c) changed = true;
+    newChildren.push(nc);
+  }
+  return {
+    start: newStart,
+    end: newEnd,
+    children: changed ? newChildren : node2.children
+  };
+}
+
 // src/functional/doc.ts
+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, pos, path = []) {
+function findContaining(node2, nodeAbsStart, pos, path = []) {
   for (let i = 0; i < node2.children.length; i++) {
     const child = node2.children[i];
     if (!isNode(child)) continue;
-    if (child.span.start <= pos && pos < child.span.end) {
-      const inner = findContaining(child, pos, [...path, i]);
+    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] };
     }
   }
@@ -6401,24 +6663,20 @@ function replaceAtPath(rebuild, root, path, newNode) {
 function defaultRebuild(node2, children) {
   return { ...node2, children };
 }
-function shiftSpans(child, delta) {
+function shiftRelStart(child, delta) {
   const c = child;
-  const span = { start: c.span.start + delta, end: c.span.end + delta };
-  if (Array.isArray(c.children)) {
-    return { ...c, span, children: c.children.map((g) => shiftSpans(g, delta)) };
-  }
-  return { ...c, span };
+  return { ...c, span: { start: c.span.start + delta, end: c.span.end + delta } };
 }
-function graftAndShift(root, path, newNode, 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 : graftAndShift(child, rest, newNode, delta);
+      return rest.length === 0 ? newNode : graftRelative(child, rest, newNode, delta);
     }
-    return shiftSpans(child, delta);
+    return shiftRelStart(child, delta);
   });
   return {
     ...root,
@@ -6426,6 +6684,96 @@ function graftAndShift(root, path, newNode, delta) {
     children: newChildren
   };
 }
+function parseMiddle(input, reStart, reEnd, cStart, ruleFn, separator, build) {
+  const ctx = { trackLines: false, state: null, build };
+  const out = [];
+  let pos = reStart;
+  let guard2 = 0;
+  while (pos < reEnd) {
+    if (++guard2 > 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) {
+  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);
+  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);
+      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;
@@ -6469,27 +6817,68 @@ function boundaryIsSafe(ruleFn, newInput, start, boundary, state, build, produce
 }
 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;
-  tree;
+  /**
+   * 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;
   input;
-  constructor(registry, rootRule, opts, tree, errors, input) {
+  constructor(registry, rootRule, opts, trees, errors, 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.tree = tree;
+    this._abs = trees.abs;
+    this._rel = trees.rel;
     this.errors = errors;
     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);
+  }
   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);
-    if (!this.tree) return reparse();
+    const root = this.tree;
+    if (!root) return reparse();
     const delta = replacement.length - (to - from);
-    const found = findContaining(this.tree, from);
-    if (!found) return reparse();
-    const ancestors = ancestorsAt(this.tree, found.path);
+    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--) {
@@ -6498,37 +6887,50 @@ var ParseDocImpl = class _ParseDocImpl {
     }
     const rebuild = this._opts.rebuild ?? defaultRebuild;
     for (const { node: node2, path } of candidates) {
-      if (node2.span.end - node2.span.start > this.input.length * REENTRY_MAX_SPAN_FRACTION) break;
-      const ruleFn = this._registry[node2.type];
+      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 (!(node2.span.start <= from && to <= node2.span.end)) continue;
+      if (!(absStart <= from && to <= absEnd)) continue;
       const ctx = { trackLines: false, state: node2.state, build: this._opts.build };
-      const r = ruleFn(newInput, node2.span.start, ctx);
+      const r = ruleFn(newInput, absStart, ctx);
       if (!r.ok) continue;
-      if (r.span.end !== node2.span.end + delta) continue;
-      if (!boundaryIsSafe(ruleFn, newInput, node2.span.start, node2.span.end + delta, node2.state, this._opts.build, r)) {
+      if (r.span.end !== absEnd + delta) continue;
+      if (!boundaryIsSafe(ruleFn, newInput, absStart, absEnd + delta, node2.state, this._opts.build, r)) {
         continue;
       }
+      const parentBase = absStart - node2.span.start;
+      const newRel = relativizeCST(r.value, parentBase);
       if (delta === 0) {
-        const newTree2 = replaceAtPath(rebuild, this.tree, path, r.value);
-        return new _ParseDocImpl(this._registry, this._rootRule, this._opts, newTree2, [], newInput);
+        const newTree2 = replaceAtPath(rebuild, root, path, newRel);
+        return new _ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: newTree2 }, [], newInput);
       }
       if (this._opts.rebuild) return reparse();
-      const newTree = graftAndShift(this.tree, path, r.value, delta);
-      return new _ParseDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput);
+      const newTree = graftRelative(root, path, newRel, delta);
+      return new _ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: 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);
+        if (spliced) return new _ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: spliced }, [], newInput);
+      }
     }
     return reparse();
   }
 };
 function parseDoc(registry, rootRule, input, opts = {}) {
-  const ruleFn = registry[rootRule];
-  if (!ruleFn) throw new Error(`No rule '${rootRule}' in registry`);
+  const entry = registry[rootRule];
+  if (!entry) throw new Error(`No rule '${rootRule}' in registry`);
   const ctx = { trackLines: false, state: opts.state, build: opts.build };
-  const r = ruleFn(input, 0, ctx);
+  const r = asRuleFn(entry)(input, 0, ctx);
   if (r.ok) {
-    return new ParseDocImpl(registry, rootRule, opts, r.value, [], input);
+    return new ParseDocImpl(registry, rootRule, opts, { abs: r.value }, [], input);
   }
-  return new ParseDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input);
+  return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [{ ok: false, expected: r.expected, span: r.span }], input);
 }
 
 // src/functional/run.ts
@@ -6897,72 +7299,6 @@ function buildOffsetIndex(root, input = "") {
   return new OffsetIndex(collectLeafSlots(root), 0, input.length);
 }
 
-// src/cst/relative-spans.ts
-function relativize(node2, parentBase = 0) {
-  return {
-    start: node2.start - parentBase,
-    end: node2.end - parentBase,
-    children: node2.children.map((c) => relativize(c, node2.start))
-  };
-}
-function absolutize(node2, parentBase = 0) {
-  const start = parentBase + node2.start;
-  return {
-    start,
-    end: parentBase + node2.end,
-    children: node2.children.map((c) => absolutize(c, start))
-  };
-}
-function absoluteSpanAt(root, path) {
-  let base = 0;
-  let node2 = root;
-  for (const idx of path) {
-    base += node2.start;
-    const child = node2.children[idx];
-    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join(".")}`);
-    node2 = child;
-  }
-  return { start: base + node2.start, end: base + node2.end };
-}
-function shiftAbsolute(node2, at, delta) {
-  const s = node2.start >= at ? node2.start + delta : node2.start;
-  const e = node2.end >= at ? node2.end + delta : node2.end;
-  return {
-    start: s,
-    end: e,
-    children: node2.children.map((c) => shiftAbsolute(c, at, delta))
-  };
-}
-function applyEdit(root, at, delta, stats) {
-  return editNode(root, at, delta, 0, 0, stats);
-}
-function editNode(node2, at, delta, parentBase, parentShift, stats) {
-  const absStart = parentBase + node2.start;
-  const absEnd = parentBase + node2.end;
-  if (absEnd < at) return node2;
-  const startShifts = absStart >= at;
-  if (startShifts && parentShift === delta) return node2;
-  if (stats) stats.allocated++;
-  const newAbsStart = startShifts ? absStart + delta : absStart;
-  const newAbsEnd = absEnd + delta;
-  const newParentBase = parentBase + parentShift;
-  const newStart = newAbsStart - newParentBase;
-  const newEnd = newAbsEnd - newParentBase;
-  const ownShift = newAbsStart - absStart;
-  let changed = false;
-  const newChildren = [];
-  for (const c of node2.children) {
-    const nc = editNode(c, at, delta, absStart, ownShift, stats);
-    if (nc !== c) changed = true;
-    newChildren.push(nc);
-  }
-  return {
-    start: newStart,
-    end: newEnd,
-    children: changed ? newChildren : node2.children
-  };
-}
-
 // src/index.ts
 registerRegexAnalyzer(firstSetFromRegex);
 //# sourceMappingURL=index.cjs.map