parseman 0.43.0 → 0.45.0

package/dist/language-service/index.cjs

@@ -102,6 +102,7 @@ function probeAt(sentinel, input, pos, ctx) {
     _cstRawChildren: ctx._cstRawChildren,
     _cstTriviaLog: ctx._cstTriviaLog,
     _triviaLog: ctx._triviaLog,
+    _rootTriviaLog: ctx._rootTriviaLog,
     _fields: ctx._fields,
     _cstBuf: ctx._cstBuf,
     _tolerant: ctx._tolerant,
@@ -114,6 +115,7 @@ function probeAt(sentinel, input, pos, ctx) {
   ctx._cstRawChildren = void 0;
   ctx._cstTriviaLog = void 0;
   ctx._triviaLog = void 0;
+  ctx._rootTriviaLog = void 0;
   ctx._fields = void 0;
   ctx._cstBuf = void 0;
   ctx._tolerant = void 0;
@@ -128,6 +130,7 @@ function probeAt(sentinel, input, pos, ctx) {
     ctx._cstRawChildren = s._cstRawChildren;
     ctx._cstTriviaLog = s._cstTriviaLog;
     ctx._triviaLog = s._triviaLog;
+    ctx._rootTriviaLog = s._rootTriviaLog;
     ctx._fields = s._fields;
     ctx._cstBuf = s._cstBuf;
     ctx._tolerant = s._tolerant;
@@ -185,105 +188,97 @@ var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSet
 // src/cst/trivia-entries.ts
 var EMPTY_INDICES = Object.freeze([]);
 var EMPTY_GAPS = Object.freeze([]);
-function entryOffset(i, stride) {
-  return i * stride;
-}
-function triviaEntries(log, labels, opts) {
-  const baseStride = opts?.nodeLog ? 3 : 2;
-  const stride = labels ? baseStride + 1 : baseStride;
-  const length = Math.floor(log.length / stride);
-  return {
+var SELECTED_ROOT_STRIDE = 5;
+function buildRootTriviaIndex(log, labels) {
+  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
+  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
+  const ownedRangeStart = (i) => log[markerOffset(i)];
+  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
+  const markerStart = (i) => log[markerOffset(i) + 2];
+  const markerEnd = (i) => log[markerOffset(i) + 3];
+  const markerKind = (i) => log[markerOffset(i) + 4];
+  const entries = {
     length,
     labels,
-    stride,
-    start(i) {
-      return log[entryOffset(i, stride)];
-    },
-    end(i) {
-      return log[entryOffset(i, stride) + 1];
-    },
-    insertIndex(i) {
-      return opts?.nodeLog ? log[entryOffset(i, stride) + 2] : void 0;
-    },
-    kindIndex(i) {
-      if (!labels) return void 0;
-      return log[entryOffset(i, stride) + baseStride];
-    },
+    stride: SELECTED_ROOT_STRIDE,
+    start: markerStart,
+    end: markerEnd,
+    insertIndex: () => void 0,
+    kindIndex: markerKind,
     kind(i) {
-      const ki = labels ? log[entryOffset(i, stride) + baseStride] : void 0;
-      return ki !== void 0 ? labels[ki] : void 0;
+      return labels[markerKind(i)];
     },
     text(i, input) {
-      const s = log[entryOffset(i, stride)];
-      const e = log[entryOffset(i, stride) + 1];
-      return input.slice(s, e);
+      return input.slice(markerStart(i), markerEnd(i));
     }
   };
-}
-function appendEntryRange(map, key, first, last) {
-  let indices = map.get(key);
-  if (!indices) {
-    indices = [];
-    map.set(key, indices);
-  }
-  for (let i = first; i <= last; i++) indices.push(i);
-}
-function buildGap(entries, start, end, first, last) {
-  const entryIndices = [];
-  for (let i = first; i <= last; i++) entryIndices.push(i);
-  return {
-    start,
-    end,
-    entryIndices,
-    hasKind(kind) {
-      for (const i of entryIndices) {
-        if (entries.kind(i) === kind) return true;
-      }
-      return false;
-    },
-    text(input) {
-      return input.slice(start, end);
+  const lowerBound = (offset, by) => {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (by(mid) < offset) lo = mid + 1;
+      else hi = mid;
     }
+    return lo;
   };
-}
-function buildRootMaps(entries) {
-  const before = /* @__PURE__ */ new Map();
-  const after = /* @__PURE__ */ new Map();
-  const beforeGaps = /* @__PURE__ */ new Map();
-  const afterGaps = /* @__PURE__ */ new Map();
-  const gaps = [];
-  if (entries.length === 0) return { before, after, beforeGaps, afterGaps, gaps };
-  const appendGap = (first2, last, start2, end2) => {
-    const gap = buildGap(entries, start2, end2, first2, last);
-    gaps.push(gap);
-    afterGaps.set(start2, gap);
-    beforeGaps.set(end2, gap);
-    appendEntryRange(after, start2, first2, last);
-    appendEntryRange(before, end2, first2, last);
+  const gapRowsAt = (offset, direction) => {
+    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
+    let first = lowerBound(offset, edge);
+    if (first === length || edge(first) !== offset) return void 0;
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
+    let last = first + 1;
+    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
+    return [first, last];
+  };
+  const indices = (first, last) => {
+    const out = [];
+    for (let i = first; i < last; i++) out.push(i);
+    return out;
+  };
+  const makeGap = (first, last) => {
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    let entryIndices;
+    return {
+      start,
+      end,
+      get entryIndices() {
+        return entryIndices ??= indices(first, last);
+      },
+      hasKind(kind) {
+        for (let i = first; i < last; i++) {
+          if (labels[markerKind(i)] === kind) return true;
+        }
+        return false;
+      },
+      text(input) {
+        return input.slice(start, end);
+      }
+    };
   };
-  let first = 0;
-  let start = entries.start(0);
-  let end = entries.end(0);
-  for (let i = 1; i < entries.length; i++) {
-    const nextStart = entries.start(i);
-    const nextEnd = entries.end(i);
-    if (nextStart === end) {
-      end = nextEnd;
-      continue;
-    }
-    appendGap(first, i - 1, start, end);
-    first = i;
-    start = nextStart;
-    end = nextEnd;
-  }
-  appendGap(first, entries.length - 1, start, end);
-  return { before, after, beforeGaps, afterGaps, gaps };
-}
-function buildRootTriviaIndex(log, labels) {
-  const entries = triviaEntries(log, labels);
   let maps;
   const getMaps = () => {
-    maps ??= buildRootMaps(entries);
+    if (maps !== void 0) return maps;
+    const before = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    const beforeGaps = /* @__PURE__ */ new Map();
+    const afterGaps = /* @__PURE__ */ new Map();
+    const gaps = [];
+    for (let first = 0; first < length; ) {
+      let last = first + 1;
+      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+      const gap = makeGap(first, last);
+      gaps.push(gap);
+      afterGaps.set(gap.start, gap);
+      beforeGaps.set(gap.end, gap);
+      after.set(gap.start, [...gap.entryIndices]);
+      before.set(gap.end, [...gap.entryIndices]);
+      first = last;
+    }
+    maps = { before, after, beforeGaps, afterGaps, gaps };
     return maps;
   };
   return {
@@ -296,16 +291,20 @@ function buildRootTriviaIndex(log, labels) {
       return getMaps().after;
     },
     entryIndicesBefore(offset) {
-      return getMaps().before.get(offset) ?? EMPTY_INDICES;
+      const rows = gapRowsAt(offset, "before");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
     },
     entryIndicesAfter(offset) {
-      return getMaps().after.get(offset) ?? EMPTY_INDICES;
+      const rows = gapRowsAt(offset, "after");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
     },
     gapBefore(offset) {
-      return getMaps().beforeGaps.get(offset);
+      const rows = gapRowsAt(offset, "before");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
     },
     gapAfter(offset) {
-      return getMaps().afterGaps.get(offset);
+      const rows = gapRowsAt(offset, "after");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
     },
     gaps() {
       return getMaps().gaps;
@@ -313,13 +312,21 @@ function buildRootTriviaIndex(log, labels) {
     gapsWithKind(kind) {
       const kinds = typeof kind === "string" ? [kind] : kind;
       const matches2 = [];
-      for (const gap of getMaps().gaps) {
-        for (const k of kinds) {
-          if (gap.hasKind(k)) {
-            matches2.push(gap);
-            break;
+      for (let first = 0; first < length; ) {
+        let last = first + 1;
+        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+        let matched = false;
+        for (let i = first; i < last && !matched; i++) {
+          const label2 = labels[markerKind(i)];
+          for (const kind2 of kinds) {
+            if (label2 === kind2) {
+              matched = true;
+              break;
+            }
           }
         }
+        if (matched) matches2.push(makeGap(first, last));
+        first = last;
       }
       return matches2.length === 0 ? EMPTY_GAPS : matches2;
     }
@@ -344,12 +351,54 @@ function assertHostModeCompatible(mode, build, hostBranchElided = true) {
 }
 
 // src/functional/run.ts
+var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
+var REMOVED_RUN_RESULT_FIELDS = [
+  [
+    "triviaMap",
+    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
+  ],
+  [
+    "triviaLog",
+    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
+  ],
+  [
+    "triviaKindLabels",
+    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
+  ]
+];
+function guardRemovedFields(result) {
+  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
+    Object.defineProperty(result, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        throw new TypeError(
+          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
+        );
+      }
+    });
+  }
+  return result;
+}
 var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
 function triviaKindLabelsFromRunnable(r) {
   if (!r) return void 0;
   if (typeof r === "function") return r._meta?.triviaKindLabels;
   const grammarTrivia = r._meta.grammarTrivia;
-  return r._meta.triviaKindLabels ?? grammarTrivia?._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
+}
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
+  }
+  return index;
 }
 function runOnce(entry, input, options, phase, profileState) {
   if (typeof entry !== "function" && typeof entry?.parse !== "function") {
@@ -357,13 +406,31 @@ function runOnce(entry, input, options, phase, profileState) {
       `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 rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
   const errors = [];
   const 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);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
+  }
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
+  }
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
+  }
   const stamped = entry;
   assertHostModeCompatible(
     typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
@@ -372,7 +439,15 @@ function runOnce(entry, input, options, phase, profileState) {
   );
   const ctx = {
     trackLines: false,
-    ...skipGlobalSinks ? { _pmProfile: profile } : { _triviaLog: triviaLog, _errors: errors, ...profile === void 0 ? {} : { _pmProfile: profile } },
+    ...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 } : {},
@@ -397,43 +472,21 @@ function runOnce(entry, input, options, phase, profileState) {
     span: r.span ?? { start: 0, end: 0 },
     expected: r.ok ? [] : r.expected ?? [],
     errors,
-    triviaLog,
-    ...triviaKindLabels === void 0 ? {} : { triviaKindLabels },
-    triviaMap: buildRootTriviaIndex(triviaLog, triviaKindLabels),
+    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
+      rootTrivia: {
+        rows: selectedRootLog,
+        select: rootTriviaSelection,
+        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+      }
+    } : {},
     unconsumedFrom
   };
 }
-function clonePassState(state) {
-  if (state === null || typeof state !== "object") return state;
-  return Array.isArray(state) ? [...state] : { ...state };
-}
-function profilePass(entry, input, options, phase) {
-  const state = { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 };
-  const passOptions = options.state === void 0 ? options : { ...options, state: clonePassState(options.state) };
-  const start = performance.now();
-  const result = runOnce(entry, input, passOptions, phase, state);
-  const { phase: _phase, ...counts } = state;
-  return { result, profile: { ms: performance.now() - start, ...counts } };
-}
 function run(entry, input, options = {}) {
-  if (!options.profile) return runOnce(entry, input, options);
-  if (typeof entry !== "function") {
-    throw new TypeError("run({ profile: true }) requires a compiled parser entry");
-  }
-  const recognizer = profilePass(entry, input, options, "recognizer");
-  const capture = profilePass(entry, input, options, "capture");
-  const host = profilePass(entry, input, options, "host");
-  if (recognizer.result.ok !== host.result.ok || capture.result.ok !== host.result.ok || recognizer.result.unconsumedFrom !== host.result.unconsumedFrom || capture.result.unconsumedFrom !== host.result.unconsumedFrom) {
-    throw new Error("run({ profile: true }) changed recognition; the grammar is not profile-safe");
-  }
-  return {
-    ...host.result,
-    profile: {
-      recognizer: recognizer.profile,
-      structuralCapture: capture.profile,
-      hostConstruction: host.profile
-    }
-  };
+  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."
+  );
 }
 
 // src/combinators/completions.ts
@@ -458,6 +511,10 @@ var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
 
 // src/compiler/scannable-run.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 = [
@@ -466,6 +523,18 @@ var CAP_RECORD = [
   `    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/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/compiler/linker.ts
 function normalizeCstCollapse(collapse) {