scip-query 0.3.5 → 0.4.1

package/dist/{chunk-F7XU27LU.js → chunk-CBIWNZZZ.js}

@@ -1,6 +1,11 @@
+import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/bottlenecks.ts
 function bottlenecks(db, opts = {}) {
@@ -39,7 +44,7 @@ function bottlenecks(db, opts = {}) {
     minFanOut,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     fanIn: r.fan_in,
@@ -47,9 +52,28 @@ function bottlenecks(db, opts = {}) {
     score: r.fan_in * r.fan_out,
     definedIn: r.defined_in
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const fanIn = new Set(
+      getCallerRowsForSymbol(db, definition, { limit: 500 }).map((row) => row.file)
+    ).size;
+    const fanOut = new Set(
+      getCalleeRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
+    ).size;
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      fanIn,
+      fanOut,
+      score: fanIn * fanOut,
+      definedIn: definition.relativePath
+    };
+  }).filter((row) => row.fanIn >= minFanIn && row.fanOut >= minFanOut).sort((left, right) => right.score - left.score || right.fanIn - left.fanIn).slice(0, limit);
 }
 
 export {
   bottlenecks
 };
-//# sourceMappingURL=chunk-F7XU27LU.js.map
+//# sourceMappingURL=chunk-CBIWNZZZ.js.map

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

@@ -2,12 +2,12 @@ import {
   findFirstSymbolMatch,
   getSourceImports,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   isModuleLikeSymbol,
   leafName,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/imports.ts
 function imports(db, filePattern) {
@@ -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-DUJNJQPO.js.map

package/dist/{chunk-GSH2FPKV.js → chunk-EAGKJFDX.js}

@@ -2,10 +2,10 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getSourceReferenceSites
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/dataflow.ts
 function dataflow(db, symbolPattern) {
@@ -84,4 +84,4 @@ function uniqueSymbolRows(rows) {
 export {
   dataflow
 };
-//# sourceMappingURL=chunk-GSH2FPKV.js.map
+//# sourceMappingURL=chunk-EAGKJFDX.js.map

package/dist/{chunk-VIYSWZCO.js → chunk-ELFGD5EW.js}

@@ -1,9 +1,12 @@
 import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol,
   testFileExclusionSql
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/complexity-hotspots.ts
 function complexityHotspots(db, opts) {
@@ -80,7 +83,7 @@ function complexityHotspots(db, opts) {
     minLoc,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     file: r.file,
@@ -94,9 +97,34 @@ function complexityHotspots(db, opts) {
       r.loc / 50 * (r.fan_in / 5) * Math.max(r.fan_out / 5, 1) * 100
     ) / 100
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const loc = definition.endLine - definition.startLine + 1;
+    const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
+    const calleeRows = getCalleeRowsForSymbol(db, definition, { limit: 500 });
+    const fanIn = new Set(callerRows.map((row) => row.file)).size;
+    const fanOut = new Set(
+      calleeRows.filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
+    ).size;
+    const calleeCount = new Set(calleeRows.map((row) => `${row.symbol}|${row.file}`)).size;
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc,
+      fanIn,
+      fanOut,
+      calleeCount,
+      score: Math.round(loc / 50 * (fanIn / 5) * Math.max(fanOut / 5, 1) * 100) / 100
+    };
+  }).filter((row) => row.loc >= minLoc).sort((left, right) => right.score - left.score || right.loc - left.loc).slice(0, limit);
 }
 
 export {
   complexityHotspots
 };
-//# sourceMappingURL=chunk-VIYSWZCO.js.map
+//# sourceMappingURL=chunk-ELFGD5EW.js.map

package/dist/chunk-FVJE4MQL.js

@@ -0,0 +1,37 @@
+import {
+  findFirstSymbolMatch,
+  getDefinitionsForFile
+} from "./chunk-ALUFWH3U.js";
+import {
+  leafName,
+  leafSuffix
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/methods.ts
+import { basename } from "path";
+function methods(db, className) {
+  const classMatch = findFirstSymbolMatch(db, className);
+  if (!classMatch) {
+    return [];
+  }
+  const ownerName = leafName(classMatch.symbol);
+  const definitions = getDefinitionsForFile(db, classMatch.relativePath).filter((definition) => isCallableSymbol(definition.symbol));
+  const directMethods = definitions.filter((definition) => definition.parentTypeName === ownerName || definition.symbol.includes(ownerName));
+  const fileScopedMethods = directMethods.length > 0 ? directMethods : stripExtension(basename(classMatch.relativePath)) === ownerName ? definitions.filter((definition) => definition.symbol.includes("<invalid-global-code>")) : [];
+  return fileScopedMethods.map((definition) => ({
+    startLine: definition.startLine,
+    endLine: definition.endLine,
+    name: leafName(definition.symbol)
+  }));
+}
+function isCallableSymbol(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
+function stripExtension(relativePath) {
+  return relativePath.replace(/\.[^.]+$/, "");
+}
+
+export {
+  methods
+};
+//# sourceMappingURL=chunk-FVJE4MQL.js.map

package/dist/{chunk-NFS5W3PP.js → chunk-GNAMV3JC.js}

@@ -1,11 +1,11 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   isDirectChildSymbol,
   leafSuffix,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/members.ts
 function members(db, symbolPattern) {
@@ -34,4 +34,4 @@ function members(db, symbolPattern) {
 export {
   members
 };
-//# sourceMappingURL=chunk-NFS5W3PP.js.map
+//# sourceMappingURL=chunk-GNAMV3JC.js.map

package/dist/{chunk-TRESG7OB.js → chunk-J47VSL6I.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/convergence.ts
 function convergence(db, symbolPatternA, symbolPatternB) {
@@ -73,4 +73,4 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 export {
   convergence
 };
-//# sourceMappingURL=chunk-TRESG7OB.js.map
+//# sourceMappingURL=chunk-J47VSL6I.js.map

package/dist/chunk-J6QXMYAQ.js

@@ -0,0 +1,115 @@
+import {
+  findFirstSymbolMatch,
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-ALUFWH3U.js";
+import {
+  isFunctionLikeSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/refs.ts
+function refs(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (match) {
+    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
+    const definitionRows = includeDefinitionSite ? [{
+      relativePath: match.relativePath,
+      line: match.startLine
+    }] : [];
+    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
+      relativePath: site.file,
+      line: site.line
+    }));
+    if (sourceSites.length > 0) {
+      const seen2 = /* @__PURE__ */ new Set();
+      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
+        const key = `${site.relativePath}:${site.line}`;
+        if (seen2.has(key)) return false;
+        seen2.add(key);
+        return true;
+      });
+      return rows2;
+    }
+  }
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE m.symbol_id = ?
+      AND ${db.localSymbolPredicate}
+      AND m.role != 1
+    ORDER BY d.relative_path, c.start_line`,
+    match?.symbolId ?? -1
+  );
+  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.start_line
+  }));
+  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
+    return referenceRows;
+  }
+  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
+  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
+    referenceRows.unshift({
+      relativePath: match.relativePath,
+      line: match.startLine
+    });
+  }
+  for (const row of getRubySemanticRefs(db, match)) {
+    const key = `${row.relativePath}:${row.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    referenceRows.push(row);
+  }
+  return referenceRows;
+}
+function getRubySemanticRefs(db, match) {
+  if (!match.relativePath.endsWith(".rb")) {
+    return [];
+  }
+  const tokens = rubyReferenceTokens(match.symbol);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE '%.rb'
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const results = [];
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const source = getSourceText(db, row.relative_path);
+    if (!source) continue;
+    const lines = source.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      if (tokens.some((token) => new RegExp(`@${token}\\b|\\b${token}:`).test(line))) {
+        results.push({
+          relativePath: row.relative_path,
+          line: index
+        });
+      }
+    }
+  }
+  return results;
+}
+function rubyReferenceTokens(rawSymbol) {
+  const leaf = rawSymbol.split(":").pop() ?? rawSymbol;
+  const snake = leaf.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+  const parts = snake.split("_").filter(Boolean);
+  const candidates = /* @__PURE__ */ new Set();
+  if (snake) candidates.add(snake);
+  if (parts.length >= 1) candidates.add(parts[parts.length - 1]);
+  if (parts.length >= 2) candidates.add(parts.slice(-2).join("_"));
+  return [...candidates];
+}
+
+export {
+  refs
+};
+//# sourceMappingURL=chunk-J6QXMYAQ.js.map

package/dist/{chunk-6FKIA6EI.js → chunk-JHVQB4Y5.js}

@@ -3,37 +3,37 @@ import {
 } from "./chunk-74RFWB5T.js";
 import {
   wrapperCandidates
-} from "./chunk-4JCSOF2O.js";
+} from "./chunk-PU2254N2.js";
 import {
   similarAll
-} from "./chunk-OIDHN6GD.js";
+} from "./chunk-6CH23IAS.js";
 import {
   staleAbstractions
-} from "./chunk-YGGFLMTM.js";
+} from "./chunk-SVLUJSY7.js";
 import {
   isolated
-} from "./chunk-UQEQ6AHX.js";
+} from "./chunk-XUVPQDXW.js";
 import {
   passthroughCandidates
-} from "./chunk-ZEUCXQBN.js";
+} from "./chunk-6ECR2FLR.js";
 import {
   drift
-} from "./chunk-7KIMF5PV.js";
+} from "./chunk-RL74LF47.js";
 import {
   extractCandidates
-} from "./chunk-EPWLXXBL.js";
+} from "./chunk-3NJSJ7TE.js";
 import {
   complexityHotspots
-} from "./chunk-VIYSWZCO.js";
+} from "./chunk-ELFGD5EW.js";
 import {
   cycles
-} from "./chunk-LFJQVJYJ.js";
+} from "./chunk-OXX3QF24.js";
 import {
   dead
-} from "./chunk-LQJUPXQY.js";
+} from "./chunk-KLNKDX6A.js";
 import {
   isEntrySurface
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-JKXHHV4B.js";
 
 // src/queries/health.ts
 function health(db, opts = {}) {
@@ -218,4 +218,4 @@ function health(db, opts = {}) {
 export {
   health
 };
-//# sourceMappingURL=chunk-6FKIA6EI.js.map
+//# sourceMappingURL=chunk-JHVQB4Y5.js.map

package/dist/{chunk-YY4QGUQ5.js → chunk-JKXHHV4B.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/entry-surfaces.ts
 var liveBarrelCache = /* @__PURE__ */ new WeakMap();
@@ -81,4 +81,4 @@ export {
   isEntrySurface,
   getInactiveBarrelPaths
 };
-//# sourceMappingURL=chunk-YY4QGUQ5.js.map
+//# sourceMappingURL=chunk-JKXHHV4B.js.map

package/dist/{chunk-EN2Z2CLO.js → chunk-KG4OFQEN.js}

@@ -1,8 +1,11 @@
+import {
+  getAllDefinitions
+} from "./chunk-ALUFWH3U.js";
 import {
   leafSuffix,
   parseSymbol,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/by-kind.ts
 var KIND_NAMES = {
@@ -143,24 +146,18 @@ function kindCounts(db, opts = {}) {
   }));
 }
 function loadKindRows(db, scope) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT
-      gs.symbol,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol,
-      d.relative_path,
-      der.start_line,
-      der.end_line
-    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")}
-      ${scopeFilter}
-    ORDER BY d.relative_path, der.start_line`
-  ).filter((row) => !db.isIgnored(row.relative_path));
+  return getAllDefinitions(db, { scope }).map(mapDefinitionToKindRow);
+}
+function mapDefinitionToKindRow(definition) {
+  return {
+    symbol: definition.symbol,
+    kind: definition.kind,
+    documentation: definition.documentation,
+    enclosing_symbol: definition.enclosingSymbol,
+    relative_path: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine
+  };
 }
 function resolveKindNumber(row) {
   if (row.kind !== null && row.kind !== 0) {
@@ -216,4 +213,4 @@ export {
   byKind,
   kindCounts
 };
-//# sourceMappingURL=chunk-EN2Z2CLO.js.map
+//# sourceMappingURL=chunk-KG4OFQEN.js.map

package/dist/chunk-KLNKDX6A.js

@@ -0,0 +1,110 @@
+import {
+  getInactiveBarrelPaths,
+  isEntrySurface
+} from "./chunk-JKXHHV4B.js";
+import {
+  TEST_FILE_PATTERNS,
+  TEST_SUPPORT_PATH_PATTERNS,
+  getAllDefinitions
+} from "./chunk-ALUFWH3U.js";
+import {
+  isFunctionLikeSymbol,
+  isModuleLikeSymbol,
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/dead.ts
+function dead(db, opts = {}) {
+  const {
+    scope,
+    minLoc = 1,
+    includeTests = false,
+    skipBarrels = false,
+    includeMembers = false
+  } = opts;
+  const inactiveBarrelPaths = skipBarrels ? new Set(getInactiveBarrelPaths(db)) : /* @__PURE__ */ new Set();
+  const referenceRows = db.all(
+    `SELECT
+      m.symbol_id,
+      d.relative_path,
+      COUNT(*) AS ref_count
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.role != 1
+       ${db.pathExclusionsFor("d")}
+     GROUP BY m.symbol_id, d.relative_path`
+  );
+  const referencesBySymbol = /* @__PURE__ */ new Map();
+  for (const row of referenceRows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    if (inactiveBarrelPaths.has(row.relative_path)) continue;
+    let refsForSymbol = referencesBySymbol.get(row.symbol_id);
+    if (!refsForSymbol) {
+      refsForSymbol = /* @__PURE__ */ new Map();
+      referencesBySymbol.set(row.symbol_id, refsForSymbol);
+    }
+    refsForSymbol.set(row.relative_path, row.ref_count);
+  }
+  const definitions = getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isModuleLikeSymbol(definition.symbol)).filter((definition) => looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.isFunctionLike || !definition.enclosingSymbol || !looksValueLikeDefinition(definition.enclosingSymbol)).filter((definition) => includeTests || passesTestFileFilter(definition.relativePath)).filter((definition) => includeMembers || looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.endLine - definition.startLine + 1 >= minLoc);
+  const rows = definitions.map((definition) => {
+    const refMap = referencesBySymbol.get(definition.symbolId) ?? /* @__PURE__ */ new Map();
+    const sameFileRefs = refMap.get(definition.relativePath) ?? 0;
+    let crossFileRefs = 0;
+    for (const [relativePath, count] of refMap) {
+      if (relativePath === definition.relativePath) continue;
+      crossFileRefs += count;
+    }
+    return {
+      relative_path: definition.relativePath,
+      start_line: definition.startLine,
+      end_line: definition.endLine,
+      loc: definition.endLine - definition.startLine + 1,
+      symbol: definition.symbol,
+      same_file_refs: sameFileRefs,
+      cross_file_refs: crossFileRefs
+    };
+  }).filter((row) => row.cross_file_refs === 0).sort((a, b) => b.loc - a.loc || a.relative_path.localeCompare(b.relative_path) || a.start_line - b.start_line);
+  let deadCodeCount = 0;
+  let fileInternalCount = 0;
+  let totalLoc = 0;
+  const symbols = rows.filter((r) => !db.isIgnored(r.relative_path)).filter((r) => !isEntrySurface(db, r.relative_path)).map((r) => {
+    const kind = r.same_file_refs === 0 ? "dead-code" : "file-internal";
+    if (kind === "dead-code") deadCodeCount++;
+    else fileInternalCount++;
+    totalLoc += r.loc;
+    return {
+      relativePath: r.relative_path,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      loc: r.loc,
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      sameFileRefs: r.same_file_refs,
+      kind
+    };
+  });
+  return {
+    symbols,
+    totalCount: symbols.length,
+    deadCodeCount,
+    fileInternalCount,
+    totalLoc
+  };
+}
+function passesTestFileFilter(relativePath) {
+  const patterns = [.../* @__PURE__ */ new Set([...TEST_FILE_PATTERNS, ...TEST_SUPPORT_PATH_PATTERNS])];
+  return patterns.every((pattern) => !likeMatches(relativePath, pattern));
+}
+function likeMatches(value, pattern) {
+  const regex = new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`);
+  return regex.test(value);
+}
+function looksValueLikeDefinition(rawSymbol) {
+  return isFunctionLikeSymbol(rawSymbol) || rawSymbol.endsWith("().") || rawSymbol.endsWith(".");
+}
+
+export {
+  dead
+};
+//# sourceMappingURL=chunk-KLNKDX6A.js.map

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

@@ -1,9 +1,9 @@
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/outline.ts
 function outline(db, filePattern) {
@@ -48,4 +48,4 @@ function outline(db, filePattern) {
 export {
   outline
 };
-//# sourceMappingURL=chunk-5OMVSV6E.js.map
+//# sourceMappingURL=chunk-KYPXKV64.js.map