parseman 0.24.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,
@@ -6481,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] };
     }
   }
@@ -6518,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,
@@ -6543,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;
@@ -6586,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--) {
@@ -6615,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
@@ -7014,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