parseman 0.46.0 → 0.47.1

package/dist/language-service/index.js

@@ -46,24 +46,26 @@ function annotateSpanFromLineContext(span, ctx) {
 function cstCaptureActive(ctx) {
   return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
 }
-function pushCstChild(ctx, built, rawEntry) {
+function pushCstChild(ctx, built, rawEntry2) {
   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);
+    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, rawEntry];
+      b.raw = [b.rawSingle, rawEntry2];
       b.rawSingle = void 0;
-    } else b.rawSingle = rawEntry;
+    } 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(rawEntry);
+  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
 }
 
 // src/recovery/scan.ts
@@ -159,6 +161,45 @@ function captureError(ctx, 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([]);
@@ -340,9 +381,30 @@ var REMOVED_RUN_RESULT_FIELDS = [
     `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\`.`
   ]
 ];
-function guardRemovedFields(result) {
+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(result, name, {
+    Object.defineProperty(proto, name, {
       configurable: true,
       enumerable: false,
       get() {
@@ -352,9 +414,14 @@ function guardRemovedFields(result) {
       }
     });
   }
-  return result;
 }
 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;
@@ -374,7 +441,23 @@ function makeSelectedRootLabelIndex(labels) {
   }
   return index;
 }
-function runOnce(entry, input, options, phase, profileState) {
+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).`
@@ -385,8 +468,6 @@ function runOnce(entry, input, options, phase, profileState) {
   const selectedRootLog = captureRootTrivia ? [] : void 0;
   const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
   const errors = [];
-  const profile = profileState ?? (phase === void 0 ? void 0 : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 });
-  const skipGlobalSinks = phase === "recognizer" || phase === "capture";
   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);
@@ -411,62 +492,71 @@ function runOnce(entry, input, options, phase, profileState) {
     options.build,
     typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
   );
-  const ctx = {
-    trackLines: false,
-    ...skipGlobalSinks ? { _pmProfile: profile } : {
-      ...captureRootTrivia ? {
-        _rootTriviaLog: selectedRootLog,
-        _rootTriviaKindIndex: selectedRootLabelIndex,
-        _rootTriviaStrictScopes: true
-      } : {},
-      _errors: errors,
-      ...profile === void 0 ? {} : { _pmProfile: profile }
-    },
-    build: options.build,
-    state: options.state,
-    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...triviaKindLabels ? { triviaKindLabels } : {} } : triviaKindLabels ? { triviaKindLabels } : {},
-    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
-    ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
-    ...options.tolerant ? { _tolerant: true, _rec: REC } : {},
-    ...options.instrumentation === void 0 ? {} : options.instrumentation
-  };
+  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 = 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;
+    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 {
-    ok: r.ok,
-    value: r.ok ? r.value : void 0,
-    span: r.span ?? { start: 0, end: 0 },
-    expected: r.ok ? [] : r.expected ?? [],
+  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
+    r.ok,
+    value,
+    span,
+    expected,
     errors,
-    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
-      rootTrivia: {
-        rows: selectedRootLog,
-        select: rootTriviaSelection,
-        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
-      }
-    } : {},
+    {
+      rows: selectedRootLog,
+      select: rootTriviaSelection,
+      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+    },
     unconsumedFrom
-  };
+  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
 }
 function run(entry, input, options = {}) {
-  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options));
-  throw new TypeError(
-    "run({ profile: true }) is unavailable: profiling counters are no longer compiled into parser artifacts, and the interpreter does not implement them yet. Profiling is moving to interpreted mode."
-  );
+  return runOnce(entry, input, options);
 }
 
 // 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 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 ?? [] : [];
@@ -479,36 +569,106 @@ function deeperFail(a, b) {
   return a.span.start >= b.span.start ? a : b;
 }
 
-// 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/scannable-run.ts
+// src/regex/classes.ts
 var META = new Set("()[]{}*+?|^$.".split(""));
-var SELECTED_ROOT_OWNED_RANGE_PLACEHOLDER = Array.from(
-  { length: SELECTED_ROOT_STRIDE - 3 },
-  () => "0"
-).join(", ");
 
-// src/compiler/trivia-fast-path.ts
-var CAP_RECORD = [
-  `  if (_cap && _e > _pos) {`,
-  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
-  `    if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
-  `  }`
-].join("\n");
-var SELECTED_ROOT_FINISH = [
-  `  if (_cap && _ctx._rootTriviaCapture !== false && _ctx._rootTriviaLog !== undefined && _ctx._rootTriviaLog.length !== _rootMark) {`,
-  `    for (let _ri = _rootMark; _ri < _ctx._rootTriviaLog.length; _ri += ${SELECTED_ROOT_STRIDE}) { _ctx._rootTriviaLog[_ri] = _pos; _ctx._rootTriviaLog[_ri + 1] = _e }`,
-  `  }`
-].join("\n");
+// 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/compiler/inline-build.ts
-var ANN = String.raw`\s*\??\s*(?::[^,)=]+)?`;
-var ANY_P = String.raw`\w+${ANN}`;
-var MK_BUILD_RE = new RegExp(
-  String.raw`^\(\s*(\w+)${ANN}\s*,\s*${ANY_P}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
-);
+// 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) {
@@ -582,14 +742,48 @@ function asRuleFn(entry) {
 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 false;
+  if (!def || depth > 24) return null;
   const d = def;
   switch (d.tag) {
-    case "sepBy":
+    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 true;
+      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).
@@ -599,7 +793,7 @@ function producesRepetition(def, depth = 0) {
       try {
         inner = typeof thunk === "function" ? thunk() : void 0;
       } catch {
-        return false;
+        return null;
       }
       return producesRepetition(inner?._def, depth + 1);
     }
@@ -616,13 +810,16 @@ function producesRepetition(def, depth = 0) {
     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));
+    case "sequence": {
+      for (const p of d.parsers) {
+        const rep = producesRepetition(defOf(p), depth + 1);
+        if (rep) return rep;
+      }
+      return null;
+    }
     default:
-      return false;
+      return null;
   }
 }
 var REENTRY_MAX_SPAN_FRACTION = 0.5;
@@ -684,17 +881,18 @@ function graftRelative(root, path, newNode, delta) {
     children: newChildren
   };
 }
-function parseMiddle(input, reStart, reEnd, cStart, ruleFn, separator, build, tolerant) {
+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 && out.length > 0 && out[out.length - 1]._tag === "node") {
+    if (separator !== null && !expectElement) {
       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;
+      expectElement = true;
       continue;
     }
     let r;
@@ -706,15 +904,15 @@ function parseMiddle(input, reStart, reEnd, cStart, ruleFn, separator, build, to
     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 ? out : null;
+  return pos === reEnd && expectElement ? out : null;
 }
-function tryListSplice(root, path, C, cStart, newInput, from, to, delta, registry, build, tolerant) {
+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++;
-  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++;
@@ -733,16 +931,7 @@ function tryListSplice(root, path, C, cStart, newInput, from, to, delta, registr
   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 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;
@@ -750,17 +939,14 @@ function tryListSplice(root, path, C, cStart, newInput, from, to, delta, registr
   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);
+  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 (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);
+      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;
     }
@@ -824,7 +1010,11 @@ 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. */
+  /**
+   * 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;
@@ -845,10 +1035,11 @@ var ParseDocImpl = class _ParseDocImpl {
   constructor(registry, rootRule, opts, trees, errors, unconsumedFrom, input) {
     this._registry = registry;
     this._fns = {};
-    this._reps = /* @__PURE__ */ new Set();
+    this._reps = /* @__PURE__ */ new Map();
     for (const [name, entry] of Object.entries(registry)) {
       this._fns[name] = asRuleFn(entry);
-      if (producesRepetition(defOf(entry))) this._reps.add(name);
+      const rep = producesRepetition(defOf(entry));
+      if (rep) this._reps.set(name, rep);
     }
     this._rootRule = rootRule;
     this._opts = opts;
@@ -932,10 +1123,11 @@ var ParseDocImpl = class _ParseDocImpl {
     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 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, this._fns, this._opts.build, !!this._opts.tolerant);
+        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);
       }
     }
@@ -951,7 +1143,7 @@ function triviaOf(entry, opts) {
 function unconsumedAfter(end, input, trivia2) {
   let pos = end;
   if (trivia2 && pos < input.length) {
-    const t = trivia2.parse(input, pos, { trackLines: false });
+    const t = trivia2.parse(input, pos, createParseContext());
     if (t.ok && t.span.end > pos) pos = t.span.end;
   }
   return pos < input.length ? pos : null;