scip-query 0.3.4 → 0.4.0

package/dist/{chunk-EPWLXXBL.js → chunk-IV6NZ426.js}

@@ -1,38 +1,22 @@
 import {
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
 import {
+  isFunctionLikeSymbol,
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
 // src/queries/extract-candidates.ts
 function extractCandidates(db, opts = {}) {
   const { scope, minLoc = 10, minCallees = 6, limit = 20 } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const symbols = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}
-    ORDER BY (der.end_line - der.start_line + 1) DESC`,
-    minLoc
-  );
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) >= minLoc && isFunctionLikeSymbol(definition.symbol)).sort((left, right) => definitionLoc(right) - definitionLoc(left));
   const results = [];
   for (const sym of symbols) {
-    if (db.isIgnored(sym.relative_path)) continue;
-    const basename = sym.relative_path.split("/").pop() ?? "";
+    if (db.isIgnored(sym.relativePath)) continue;
+    const basename = sym.relativePath.split("/").pop() ?? "";
     if (basename.includes("types")) continue;
-    const calleeChunks = getCalleeRowsForSymbol(db, {
-      documentId: sym.document_id,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      symbolId: sym.id
-    });
+    const calleeChunks = getCalleeRowsForSymbol(db, sym);
     const calleeSet = new Set(calleeChunks.map((c) => c.symbol));
     if (calleeSet.size < minCallees) continue;
     const cooccurrence = /* @__PURE__ */ new Map();
@@ -95,10 +79,10 @@ function extractCandidates(db, opts = {}) {
       results.push({
         symbol: sym.symbol,
         shortName: shortenSymbol(sym.symbol),
-        relativePath: sym.relative_path,
-        startLine: sym.start_line,
-        endLine: sym.end_line,
-        loc: sym.end_line - sym.start_line + 1,
+        relativePath: sym.relativePath,
+        startLine: sym.startLine,
+        endLine: sym.endLine,
+        loc: definitionLoc(sym),
         totalCallees: calleeSet.size,
         clusters: scoredClusters
       });
@@ -107,8 +91,22 @@ function extractCandidates(db, opts = {}) {
   results.sort((a, b) => b.clusters.length - a.clusters.length || b.loc - a.loc);
   return results.slice(0, limit);
 }
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
 
 export {
   extractCandidates
 };
-//# sourceMappingURL=chunk-EPWLXXBL.js.map
+//# sourceMappingURL=chunk-IV6NZ426.js.map

package/dist/{chunk-VT4JBH6L.js → chunk-KDCQJTYW.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/deps.ts
 function deps(db, filePattern) {
@@ -50,4 +50,4 @@ export {
   deps,
   rdeps
 };
-//# sourceMappingURL=chunk-VT4JBH6L.js.map
+//# sourceMappingURL=chunk-KDCQJTYW.js.map

package/dist/{chunk-5OMVSV6E.js → chunk-LOVDB4C6.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -48,4 +48,4 @@ function outline(db, filePattern) {
 export {
   outline
 };
-//# sourceMappingURL=chunk-5OMVSV6E.js.map
+//# sourceMappingURL=chunk-LOVDB4C6.js.map

package/dist/chunk-MA3B3IUT.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafSuffix,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/surface.ts
+function surface(db, modulePattern) {
+  const matchedPaths = resolveIndexedPaths(db, modulePattern);
+  if (matchedPaths.length === 0) {
+    return [];
+  }
+  const placeholders = matchedPaths.map(() => "?").join(", ");
+  const rows = db.all(
+    `SELECT DISTINCT d1.relative_path, gs.symbol
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE d1.relative_path NOT IN (${placeholders})
+      AND (
+        EXISTS (
+          SELECT 1
+          FROM defn_enclosing_ranges der
+          JOIN documents d2 ON der.document_id = d2.id
+          WHERE der.symbol_id = gs.id
+            AND d2.relative_path IN (${placeholders})
+        )
+        OR EXISTS (
+          SELECT 1
+          FROM mentions def_m
+          JOIN chunks def_c ON def_m.chunk_id = def_c.id
+          JOIN documents d2 ON def_c.document_id = d2.id
+          WHERE def_m.symbol_id = gs.id
+            AND def_m.role = 1
+            AND d2.relative_path IN (${placeholders})
+        )
+      )
+      AND m.role != 1
+      AND ${db.localSymbolPredicate}
+      ${db.pathExclusionsFor("d1")}
+    ORDER BY d1.relative_path`,
+    ...matchedPaths,
+    ...matchedPaths,
+    ...matchedPaths
+  );
+  const exposedDefinitions = matchedPaths.flatMap(
+    (relativePath) => getDefinitionsForFile(db, relativePath).filter((definition) => isCallableSymbol(definition.symbol)).map((definition) => ({
+      relative_path: relativePath,
+      symbol: definition.symbol
+    }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return [...rows, ...exposedDefinitions].filter((r) => !db.isIgnored(r.relative_path)).filter((r) => {
+    const key = `${r.relative_path}|${r.symbol}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).map((r) => ({
+    consumer: r.relative_path,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol)
+  }));
+}
+function isCallableSymbol(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
+
+export {
+  surface
+};
+//# sourceMappingURL=chunk-MA3B3IUT.js.map

package/dist/{chunk-26DOJ63W.js → chunk-N2LH3M2P.js}

@@ -2,7 +2,7 @@ import {
   findFirstSymbolMatch,
   getSourceImports,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   isModuleLikeSymbol,
   leafName,
@@ -79,6 +79,14 @@ function importedBy(db, symbolPattern) {
       if (targetFile && normalizePath(entry.sourcePath) !== normalizePath(targetFile)) {
         continue;
       }
+      if (entry.kind === "side-effect") {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (targetFile && isCLikeImporter(row.relative_path)) {
+        importers.add(row.relative_path);
+        continue;
+      }
       if (targetIsModule) {
         importers.add(row.relative_path);
         continue;
@@ -152,10 +160,13 @@ function renderImportSymbol(importedName, localName, kind) {
 function normalizePath(path) {
   return path.replace(/\\/g, "/");
 }
+function isCLikeImporter(relativePath) {
+  return /\.(?:c|h|cc|cpp|cxx|hpp|hh|hxx)$/i.test(relativePath);
+}
 
 export {
   imports,
   importedBy,
   unusedImports
 };
-//# sourceMappingURL=chunk-26DOJ63W.js.map
+//# sourceMappingURL=chunk-N2LH3M2P.js.map

package/dist/chunk-NWCJWA36.js

@@ -0,0 +1,162 @@
+import {
+  getAllDefinitions,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/similar-signatures.ts
+function similarSignatures(db, opts = {}) {
+  const { scope, minLoc = 1, limit } = opts;
+  const sigGroups = /* @__PURE__ */ new Map();
+  for (const definition of getAllDefinitions(db, { scope })) {
+    if (!definition.isFunctionLike || db.isIgnored(definition.relativePath)) continue;
+    const loc = definition.endLine - definition.startLine + 1;
+    if (loc < minLoc) continue;
+    const normalized = resolveNormalizedSignature(db, definition);
+    if (!normalized) continue;
+    const entry = {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc
+    };
+    const existing = sigGroups.get(normalized);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      sigGroups.set(normalized, [entry]);
+    }
+  }
+  const results = [];
+  for (const [signature, functions] of sigGroups) {
+    if (functions.length < 2) continue;
+    results.push({ signature, functions });
+  }
+  results.sort((a, b) => {
+    const sizeDiff = b.functions.length - a.functions.length;
+    if (sizeDiff !== 0) return sizeDiff;
+    const locA = a.functions.reduce((sum, f) => sum + f.loc, 0);
+    const locB = b.functions.reduce((sum, f) => sum + f.loc, 0);
+    return locB - locA;
+  });
+  return limit ? results.slice(0, limit) : results;
+}
+function resolveNormalizedSignature(db, definition) {
+  const documented = extractDocumentedSignature(definition.documentation);
+  const normalizedDocumented = documented ? normalizeSignature(documented) : null;
+  if (normalizedDocumented) {
+    return normalizedDocumented;
+  }
+  return normalizeSourceSignature(
+    extractDeclarationHead(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+    definition.leaf
+  );
+}
+function extractDocumentedSignature(documentation) {
+  if (!documentation || !documentation.includes("|")) {
+    return null;
+  }
+  const extracted = documentation.slice(documentation.indexOf("|") + 1).replace(/\n/g, " ").trim();
+  return extracted.length > 0 ? extracted : null;
+}
+function extractDeclarationHead(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) return null;
+  const lines = source.split(/\r?\n/);
+  const candidates = declarationStartLines(lines, startLine, endLine, leaf);
+  for (const candidate of candidates) {
+    const maxLine = Math.min(lines.length - 1, Math.max(candidate, candidate + 4));
+    let collected = "";
+    for (let lineIndex = candidate; lineIndex <= maxLine; lineIndex += 1) {
+      const line = lines[lineIndex]?.trim();
+      if (!line) continue;
+      collected = collected ? `${collected} ${line}` : line;
+      if (looksCompleteDeclaration(collected)) {
+        return collected;
+      }
+    }
+    if (collected && collected.includes("(")) {
+      return collected;
+    }
+  }
+  return null;
+}
+function looksCompleteDeclaration(declaration) {
+  const normalized = declaration.replace(/\s+/g, " ").trim();
+  if (!normalized.includes("(")) return false;
+  if (parenBalance(normalized) > 0) return false;
+  return /[;{]$/.test(normalized) || /\)\s*(?::\s*[^={]+)?\s*(?:=>|=|throws\b|where\b|$)/i.test(normalized) || /\)\s*As\s+.+$/i.test(normalized);
+}
+function normalizeSignature(raw) {
+  if (!raw || !raw.trim()) return null;
+  let sig = raw.replace(/^```\w*\s*/, "").replace(/\s*```$/, "").replace(/^\(method\)\s*/, "").replace(/^\(property\)\s*/, "").replace(/^\(function\)\s*/, "").replace(/^\(class\)\s*/, "").replace(/^\(interface\)\s*/, "").replace(/^\(enum\)\s*/, "").replace(/^\(type alias\)\s*/, "").replace(/^\(const\)\s*/, "").replace(/^\(var\)\s*/, "").trim();
+  const parenIdx = sig.indexOf("(");
+  if (parenIdx === -1) return null;
+  sig = sig.slice(parenIdx);
+  sig = sig.replace(/\s+/g, "").toLowerCase();
+  if (sig.length < 3) return null;
+  return sig;
+}
+function normalizeSourceSignature(raw, leaf) {
+  if (!raw || !raw.trim()) return null;
+  let declaration = raw.replace(/\s+/g, " ").trim();
+  const parenIdx = declaration.indexOf("(");
+  if (parenIdx === -1) return null;
+  let prefix = declaration.slice(0, parenIdx);
+  const leafPattern = new RegExp(`\\b${escapeRegex(leaf)}\\b`, "i");
+  const leafMatch = leafPattern.exec(prefix);
+  if (leafMatch && typeof leafMatch.index === "number") {
+    prefix = prefix.slice(0, leafMatch.index);
+  }
+  prefix = prefix.replace(/\b(public|private|protected|internal|final|static|abstract|sealed|virtual|override|async|suspend|inline|constexpr|consteval|constinit|const|pub|fn|function|def|sub|friend|shared|readonly|new|open|partial|export)\b/gi, " ").replace(/\s+/g, " ").trim();
+  let suffix = declaration.slice(parenIdx).replace(/\s*\{[\s\S]*$/, "").replace(/\s*=>[\s\S]*$/, "").replace(/\)\s*=\s*[\s\S]*$/, ")").replace(/\s+throws\s+[^={]+$/i, "").replace(/\s+where\s+.+$/i, "").replace(/\s+/g, " ").trim();
+  if (!suffix.startsWith("(")) {
+    return null;
+  }
+  const normalized = `${prefix ? `${prefix} ` : ""}${suffix}`.replace(/\s+/g, "").toLowerCase();
+  return normalized.length >= 3 ? normalized : null;
+}
+function declarationStartLines(lines, startLine, endLine, leaf) {
+  const escapedLeaf = escapeRegex(leaf);
+  const callablePattern = new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`, "i");
+  const rubyPattern = new RegExp(`\\bdef\\s+${escapedLeaf}\\b`, "i");
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const preferredStart = Math.max(0, Math.min(startLine, lines.length - 1));
+  const preferredEnd = Math.max(preferredStart, Math.min(lines.length - 1, Math.max(endLine, startLine + 4)));
+  for (let lineIndex = preferredStart; lineIndex <= preferredEnd; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  return candidates;
+}
+function parenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance += 1;
+    if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  similarSignatures
+};
+//# sourceMappingURL=chunk-NWCJWA36.js.map

package/dist/{chunk-NG5F43OU.js → chunk-P3VCDYMJ.js}

@@ -1,6 +1,8 @@
 // src/reindex/install.ts
 import { execFileSync } from "child_process";
+import { existsSync } from "fs";
 import { platform } from "os";
+import { join } from "path";
 var IS_WINDOWS = platform() === "win32";
 function isBinaryAvailable(name) {
   const cmd = IS_WINDOWS ? "where" : "which";
@@ -29,6 +31,31 @@ function resolveIndexerBinary(config) {
 function isIndexerInstalled(config) {
   return resolveIndexerBinary(config) !== null;
 }
+function resolveProjectLocalIndexerBinary(config, projectRoot) {
+  for (const relativePath of config.projectLocalBinaries ?? []) {
+    const candidate = join(projectRoot, relativePath);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getIndexerExecutionEnv(config, baseEnv = process.env, binary = config.indexerBinary) {
+  if (config.indexerBinary !== "scip-dotnet") {
+    return baseEnv;
+  }
+  if (canRunDotnetIndexer(binary, baseEnv)) {
+    return baseEnv;
+  }
+  const dotnetRoot = resolveWorkingDotnetRoot(binary, baseEnv);
+  if (!dotnetRoot) {
+    return baseEnv;
+  }
+  return {
+    ...baseEnv,
+    DOTNET_ROOT: dotnetRoot
+  };
+}
 function tryInstallIndexer(config, onStatus) {
   const methods = config.installMethods;
   const binaryLabel = describeIndexerBinary(config);
@@ -68,6 +95,46 @@ function tryInstallIndexer(config, onStatus) {
   }
   return false;
 }
+function resolveWorkingDotnetRoot(binary, env) {
+  for (const dotnetRoot of getDotnetRootCandidates(env)) {
+    if (canRunDotnetIndexer(binary, { ...env, DOTNET_ROOT: dotnetRoot })) {
+      return dotnetRoot;
+    }
+  }
+  return null;
+}
+function getDotnetRootCandidates(env) {
+  const candidates = [];
+  const configured = env["DOTNET_ROOT"];
+  if (configured && existsSync(configured)) {
+    candidates.push(configured);
+  }
+  if (platform() === "darwin" && isBinaryAvailable("brew")) {
+    try {
+      const prefix = execFileSync("brew", ["--prefix", "dotnet@9"], {
+        stdio: "pipe",
+        env
+      }).toString().trim();
+      const candidate = join(prefix, "libexec");
+      if (existsSync(candidate) && !candidates.includes(candidate)) {
+        candidates.push(candidate);
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+function canRunDotnetIndexer(binary, env) {
+  try {
+    execFileSync(binary, ["--version"], {
+      stdio: "pipe",
+      env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/scip-cli.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -191,10 +258,12 @@ export {
   describeIndexerBinary,
   resolveIndexerBinary,
   isIndexerInstalled,
+  resolveProjectLocalIndexerBinary,
+  getIndexerExecutionEnv,
   tryInstallIndexer,
   isScipInstalled,
   getScipVersion,
   printScipInstallInstructions,
   tryInstallScipCli
 };
-//# sourceMappingURL=chunk-NG5F43OU.js.map
+//# sourceMappingURL=chunk-P3VCDYMJ.js.map

package/dist/{chunk-P3E6L7KW.js → chunk-P42KQKJZ.js}

@@ -1,7 +1,13 @@
 import {
   isLiveBarrel
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-X3J4VPWM.js";
 import {
+  getDefinitionsForFile,
+  getSourceExports,
+  getSourceImports
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafSuffix,
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
@@ -96,10 +102,84 @@ function redundantReexports(db, opts = {}) {
   results.sort(
     (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
   );
-  return limit ? results.slice(0, limit) : results;
+  const withDartFallback = dedupeReexports([
+    ...results,
+    ...findSourceRedundantReexports(db, scope)
+  ]);
+  withDartFallback.sort(
+    (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
+  );
+  return limit ? withDartFallback.slice(0, limit) : withDartFallback;
+}
+function findSourceRedundantReexports(db, scope) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${scope ? "AND relative_path LIKE ?" : ""}
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`,
+    ...scope ? [`%${scope}%`] : []
+  );
+  const candidates = files.map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath)).filter((relativePath) => getSourceExports(db, relativePath).length > 0);
+  const results = [];
+  for (const barrelPath of candidates) {
+    const exports = getSourceExports(db, barrelPath).filter((entry) => entry.sourcePath && !db.isIgnored(entry.sourcePath));
+    if (exports.length === 0) continue;
+    const barrelConsumers = countDirectImporters(db, barrelPath, barrelPath);
+    if (barrelConsumers > 0) continue;
+    for (const exported of exports) {
+      const sourcePath = exported.sourcePath;
+      const representative = representativeExportSymbol(db, sourcePath);
+      if (!representative) continue;
+      results.push({
+        barrelFile: barrelPath,
+        symbol: representative.symbol,
+        shortName: shortenSymbol(representative.symbol),
+        originalFile: sourcePath,
+        barrelConsumers: 0,
+        directConsumers: countDirectImporters(db, sourcePath, barrelPath)
+      });
+    }
+  }
+  return results;
+}
+function countDirectImporters(db, targetPath, excludedPath) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const importers = /* @__PURE__ */ new Set();
+  for (const row of files) {
+    if (db.isIgnored(row.relative_path) || row.relative_path === excludedPath) continue;
+    for (const imported of getSourceImports(db, row.relative_path)) {
+      if (imported.sourcePath === targetPath) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return importers.size;
+}
+function representativeExportSymbol(db, sourcePath) {
+  const definitions = getDefinitionsForFile(db, sourcePath);
+  return definitions.find((definition) => leafSuffix(definition.symbol) === "method") ?? definitions[0] ?? null;
+}
+function dedupeReexports(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.barrelFile}|${row.symbol}|${row.originalFile}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
 }
 
 export {
   redundantReexports
 };
-//# sourceMappingURL=chunk-P3E6L7KW.js.map
+//# sourceMappingURL=chunk-P42KQKJZ.js.map

package/dist/{chunk-YDBXNPYU.js → chunk-PGHN5UTM.js}

@@ -1,6 +1,6 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   parseSymbol,
   shortenSymbol
@@ -66,4 +66,4 @@ function hierarchy(db, symbolPattern) {
 export {
   hierarchy
 };
-//# sourceMappingURL=chunk-YDBXNPYU.js.map
+//# sourceMappingURL=chunk-PGHN5UTM.js.map

package/dist/{chunk-UGQKAVCD.js → chunk-QCYR4S6T.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -107,4 +107,4 @@ function stripCommentsAndStrings(source) {
 export {
   complexity
 };
-//# sourceMappingURL=chunk-UGQKAVCD.js.map
+//# sourceMappingURL=chunk-QCYR4S6T.js.map