parseman 0.42.1 → 0.44.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;
     }
@@ -349,7 +356,20 @@ 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 +377,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 +410,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,9 +443,13 @@ 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
   };
 }
@@ -458,6 +508,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 +520,11 @@ 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/linker.ts
 function normalizeCstCollapse(collapse) {
@@ -476,15 +535,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children] };
+function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children] };
 }
-function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
     return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children2 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  const materializeTags = typeOrOptions?.tags === true;
+  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children2 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -498,19 +558,6 @@ function fusedHostElidedOf(registry) {
   return registry[FUSED_HOST_ELIDED] === true;
 }
 
-// src/cst/walk.ts
-function walk(root, visitor, ctx = void 0) {
-  const go = (node2, parent) => {
-    const descend = visitor.enter ? visitor.enter(node2, parent, ctx) : void 0;
-    const children = node2.children;
-    if (descend !== false && Array.isArray(children)) {
-      for (const child of children) go(child, node2);
-    }
-    visitor.leave?.(node2, parent, ctx);
-  };
-  go(root, null);
-}
-
 // src/cst/relative-spans.ts
 function relativizeCST(node2, parentBase = 0) {
   const span = { start: node2.span.start - parentBase, end: node2.span.end - parentBase };
@@ -953,6 +1000,14 @@ function parseDoc(registry, rootRule, input, opts = {}) {
 
 // src/language-service/index.ts
 var errorMessage = (expected) => expected.length ? `Unexpected input; expected ${expected.join(" or ")}` : "Unexpected input";
+function visitTree(root, enter) {
+  const go = (node2) => {
+    enter(node2);
+    const children = node2.children;
+    if (Array.isArray(children)) for (const child of children) go(child);
+  };
+  go(root);
+}
 function mergeDiagnostics(tree, flat, unconsumedFrom, inputLength, config) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -972,17 +1027,15 @@ function mergeDiagnostics(tree, flat, unconsumedFrom, inputLength, config) {
 function diagnoseTree(root, config) {
   const out = [];
   const rules2 = config.diagnostics;
-  walk(root, {
-    enter(node2) {
-      if (node2._tag === "parseError") {
-        out.push({ severity: "error", message: errorMessage(node2.expected ?? []), span: node2.span });
-        return;
-      }
-      const h = rules2 && node2.type !== void 0 ? rules2[node2.type] : void 0;
-      if (h) {
-        const d = h(node2);
-        if (d) out.push(...Array.isArray(d) ? d : [d]);
-      }
+  visitTree(root, (node2) => {
+    if (node2._tag === "parseError") {
+      out.push({ severity: "error", message: errorMessage(node2.expected ?? []), span: node2.span });
+      return;
+    }
+    const h = rules2 && node2.type !== void 0 ? rules2[node2.type] : void 0;
+    if (h) {
+      const d = h(node2);
+      if (d) out.push(...Array.isArray(d) ? d : [d]);
     }
   });
   return out;
@@ -1040,11 +1093,9 @@ function languageService(grammar, config = {}) {
 function ruleAtCursor(root, offset) {
   if (!root || typeof root !== "object") return null;
   let best = null;
-  walk(root, {
-    enter(node2) {
-      const s = node2.span;
-      if (s && s.start <= offset && offset <= s.end && node2.type !== void 0) best = node2.type;
-    }
+  visitTree(root, (node2) => {
+    const s = node2.span;
+    if (s && s.start <= offset && offset <= s.end && node2.type !== void 0) best = node2.type;
   });
   return best;
 }