scip-query 0.3.4 → 0.4.0

package/dist/chunk-AS7N27JK.js

@@ -0,0 +1,115 @@
+import {
+  buildFileDepGraph,
+  getCallerRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/wrapper-candidates.ts
+import { basename, extname } from "path";
+function wrapperCandidates(db, opts) {
+  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
+  const reverseFanIn = buildReverseFileFanIn(buildFileDepGraph(db, scope));
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) <= maxLoc && definitionLoc(definition) >= 2);
+  const results = [];
+  for (const symbol of symbols) {
+    if (db.isIgnored(symbol.relativePath) || !isFunctionLikeSymbol(symbol.symbol)) continue;
+    const symbolStem = basename(symbol.relativePath, extname(symbol.relativePath));
+    const callerRows = dedupeRows(
+      getCallerRowsForSymbol(db, symbol, { limit: 200 }).filter((row) => row.file !== symbol.relativePath)
+    ).filter((row) => basename(row.file, extname(row.file)) !== symbolStem);
+    if (callerRows.length !== 1) continue;
+    const caller = callerRows[0];
+    const callerDefinition = getDefinitionsForFile(db, caller.file).find((definition) => definition.symbol === caller.symbol);
+    const useDefinitionFanIn = callerDefinition?.isFunctionLike ?? false;
+    let callerFanIn;
+    if (useDefinitionFanIn && callerDefinition) {
+      callerFanIn = new Set(
+        getCallerRowsForSymbol(db, callerDefinition, { limit: 500 }).filter((row) => row.file !== callerDefinition.relativePath).map((row) => row.file)
+      ).size;
+    } else {
+      callerFanIn = fallbackCallerFanIn(db, reverseFanIn, caller.file);
+    }
+    if (callerFanIn <= 3) continue;
+    results.push({
+      symbol: symbol.symbol,
+      shortName: shortenSymbol(symbol.symbol),
+      file: symbol.relativePath,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine,
+      loc: definitionLoc(symbol),
+      singleCaller: caller.symbol,
+      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename(caller.file),
+      callerFanIn
+    });
+  }
+  results.sort((left, right) => right.callerFanIn - left.callerFanIn || right.loc - left.loc);
+  return results.slice(0, limit);
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+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 dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
+function buildReverseFileFanIn(graph) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [fromFile, deps] of graph) {
+    if (!reverse.has(fromFile)) {
+      reverse.set(fromFile, reverse.get(fromFile) ?? 0);
+    }
+    for (const dep of deps) {
+      reverse.set(dep, (reverse.get(dep) ?? 0) + 1);
+    }
+  }
+  return reverse;
+}
+function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
+  const functionLikeFanIn = getDefinitionsForFile(db, callerFile).filter((definition) => definition.isFunctionLike).map((definition) => new Set(
+    getCallerRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => row.file)
+  ).size).sort((left, right) => right - left)[0] ?? 0;
+  if (functionLikeFanIn > 0) {
+    return functionLikeFanIn;
+  }
+  const direct = reverseFanIn.get(callerFile) ?? 0;
+  if (direct > 0) {
+    return direct;
+  }
+  const stem = basename(callerFile, extname(callerFile));
+  let best = 0;
+  for (const [file, fanIn] of reverseFanIn) {
+    if (file === callerFile) continue;
+    if (basename(file, extname(file)) !== stem) continue;
+    if (fanIn > best) {
+      best = fanIn;
+    }
+  }
+  return best;
+}
+
+export {
+  wrapperCandidates
+};
+//# sourceMappingURL=chunk-AS7N27JK.js.map

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

@@ -1,3 +1,8 @@
+import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -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-CQRYLK33.js.map

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

@@ -1,6 +1,6 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   isDirectChildSymbol,
   leafSuffix,
@@ -34,4 +34,4 @@ function members(db, symbolPattern) {
 export {
   members
 };
-//# sourceMappingURL=chunk-NFS5W3PP.js.map
+//# sourceMappingURL=chunk-CQUNEJYM.js.map

package/dist/chunk-D4I3ZMN5.js

@@ -0,0 +1,38 @@
+import {
+  cleanSignature
+} from "./chunk-4TYLS5XX.js";
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/symbols.ts
+function symbols(db, filePattern) {
+  const resolvedPaths = resolveIndexedPaths(db, filePattern);
+  if (resolvedPaths.length === 0) {
+    return [];
+  }
+  return resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((row) => !db.isIgnored(row.relativePath)).map((row) => {
+    const docRow = db.get(
+      `SELECT REPLACE(SUBSTR(documentation, INSTR(documentation, '|') + 1), char(10), ' ') AS sig
+         FROM global_symbols
+         WHERE id = ?`,
+      row.symbolId
+    );
+    return {
+      startLine: row.startLine,
+      endLine: row.endLine,
+      symbol: row.symbol,
+      shortName: shortenSymbol(row.symbol),
+      signature: cleanSignature(docRow?.sig ?? null)
+    };
+  });
+}
+
+export {
+  symbols
+};
+//# sourceMappingURL=chunk-D4I3ZMN5.js.map

package/dist/{chunk-J3JSOSUO.js → chunk-E7J7Q7UW.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -76,4 +76,4 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 export {
   code
 };
-//# sourceMappingURL=chunk-J3JSOSUO.js.map
+//# sourceMappingURL=chunk-E7J7Q7UW.js.map

package/dist/{chunk-GEXE2T6I.js → chunk-EOHPASDV.js}

@@ -3,8 +3,9 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   findFirstSymbolMatch,
-  getSourceReferenceSites
-} from "./chunk-AXQKUYKF.js";
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
 import {
   isFunctionLikeSymbol,
   shortenSymbol
@@ -16,24 +17,22 @@ function trace(db, symbolPattern) {
   if (!match) {
     return { definitions: [], referencedBy: [] };
   }
-  const defRows = db.all(
-    `SELECT d.relative_path, der.start_line, der.end_line,
+  const definitionMeta = db.get(
+    `SELECT
       gs.display_name,
       REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
     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 gs.id = ?
-    ORDER BY d.relative_path, der.start_line
     LIMIT 10`,
     match.symbolId
   );
-  const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    signature: buildTraceSignature(r.sig, r.display_name, match.symbol)
-  }));
+  const definitions = db.isIgnored(match.relativePath) ? [] : [{
+    relativePath: match.relativePath,
+    startLine: match.startLine,
+    endLine: match.endLine,
+    signature: buildTraceSignature(definitionMeta?.sig ?? null, definitionMeta?.display_name ?? null, match.symbol),
+    source: definitionSource(db, match.relativePath, match.startLine, match.endLine)
+  }];
   const sourceSites = getSourceReferenceSites(db, match);
   const referencedBy = sourceSites.length > 0 ? sourceSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
     relativePath: site.file,
@@ -66,6 +65,15 @@ function trace(db, symbolPattern) {
   }));
   return { definitions, referencedBy };
 }
+function definitionSource(db, relativePath, startLine, endLine) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return null;
+  }
+  const lines = source.split("\n");
+  const slice = lines.slice(startLine, endLine + 1).join("\n").trimEnd();
+  return slice.length > 0 ? slice : null;
+}
 function buildTraceSignature(signature, displayName, rawSymbol) {
   const cleaned = cleanSignature(signature);
   if (cleaned && !looksBogusSignature(cleaned)) {
@@ -84,4 +92,4 @@ function looksBogusSignature(signature) {
 export {
   trace
 };
-//# sourceMappingURL=chunk-GEXE2T6I.js.map
+//# sourceMappingURL=chunk-EOHPASDV.js.map

package/dist/chunk-FVH3Y44U.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-FVH3Y44U.js.map

package/dist/chunk-GIBETK3W.js

@@ -0,0 +1,37 @@
+import {
+  findFirstSymbolMatch,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafName,
+  leafSuffix
+} from "./chunk-QIXNAB5K.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-GIBETK3W.js.map

package/dist/{chunk-SMDCNPMK.js → chunk-H3FPW5YN.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -68,4 +68,4 @@ function changeSurface(db, filePattern) {
 export {
   changeSurface
 };
-//# sourceMappingURL=chunk-SMDCNPMK.js.map
+//# sourceMappingURL=chunk-H3FPW5YN.js.map

package/dist/{chunk-GJDHTTR2.js → chunk-HNURMDF4.js}

@@ -1,27 +1,30 @@
 import {
+  buildFileDepGraph,
+  findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
 // src/queries/fan.ts
 function fanIn(db, symbolPattern) {
-  const rows = db.all(
-    `SELECT gs.symbol, COUNT(DISTINCT c.document_id) AS file_count
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE gs.symbol LIKE ?
-      AND m.role != 1
-    GROUP BY gs.id
-    ORDER BY file_count DESC`,
-    `%${symbolPattern}%`
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) {
+    return [];
+  }
+  const row = db.get(
+    `SELECT COUNT(DISTINCT c.document_id) AS file_count
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1`,
+    match.symbolId
   );
-  return rows.map((r) => ({
-    name: shortenSymbol(r.symbol),
-    count: r.file_count
-  }));
+  return [{
+    name: shortenSymbol(match.symbol),
+    count: row?.file_count ?? 0
+  }];
 }
 function fanOut(db, filePattern) {
   const resolvedFile = resolveIndexedFile(db, filePattern);
@@ -43,10 +46,22 @@ function fanOut(db, filePattern) {
     ORDER BY symbol_count DESC`,
     resolvedFile
   );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     name: r.relative_path,
     count: r.symbol_count
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const graph = buildFileDepGraph(db);
+  const deps = graph.get(resolvedFile);
+  if (!deps || deps.size === 0) {
+    return [];
+  }
+  return [{
+    name: resolvedFile,
+    count: deps.size
+  }];
 }
 function topFanIn(db, opts = {}) {
   const { limit = 30, scope } = opts;
@@ -106,4 +121,4 @@ export {
   topFanIn,
   topFanOut
 };
-//# sourceMappingURL=chunk-GJDHTTR2.js.map
+//# sourceMappingURL=chunk-HNURMDF4.js.map

package/dist/{chunk-7KIMF5PV.js → chunk-HRDPUTIQ.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/drift.ts
 import path from "path";
@@ -162,4 +162,4 @@ function isTestLikePath(filePath) {
 export {
   drift
 };
-//# sourceMappingURL=chunk-7KIMF5PV.js.map
+//# sourceMappingURL=chunk-HRDPUTIQ.js.map

package/dist/{chunk-OIDHN6GD.js → chunk-I2JM34UV.js}

@@ -1,9 +1,12 @@
 import {
   findFirstSymbolMatch,
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
 import {
   isFunctionLikeSymbol,
+  leafName,
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
@@ -11,7 +14,7 @@ import {
 function similar(db, symbolPattern, opts = {}) {
   const { minSimilarity = 0.4, limit = 20 } = opts;
   const target = findCallees(db, symbolPattern);
-  if (!target || target.callees.size === 0) return [];
+  if (!target) return [];
   if (!isFunctionLikeSymbol(target.symbol)) return [];
   const candidates = getAllCalleeFingerprints(db, {
     minCallees: 3,
@@ -43,7 +46,10 @@ function similar(db, symbolPattern, opts = {}) {
     });
   }
   results.sort((a, b) => b.similarity - a.similarity);
-  return results.slice(0, limit);
+  if (results.length > 0) {
+    return results.slice(0, limit);
+  }
+  return similarBySourceShape(db, symbolPattern, { minSimilarity, limit });
 }
 function similarAll(db, opts = {}) {
   const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4 } = opts;
@@ -190,9 +196,144 @@ function difference(a, b) {
   }
   return result;
 }
+function similarBySourceShape(db, symbolPattern, opts) {
+  const target = findSourceFingerprint(db, symbolPattern);
+  if (!target || target.tokens.size < 3) {
+    return [];
+  }
+  const minSimilarity = opts.minSimilarity >= 0.5 ? opts.minSimilarity : 0.3;
+  const results = [];
+  for (const candidate of getAllSourceFingerprints(db)) {
+    if (candidate.symbol === target.symbol || candidate.tokens.size < 3) continue;
+    const shared = intersection(target.tokens, candidate.tokens);
+    if (shared.size < 2) continue;
+    const union = /* @__PURE__ */ new Set([...target.tokens, ...candidate.tokens]);
+    const similarity = union.size > 0 ? shared.size / union.size : 0;
+    if (similarity < minSimilarity) continue;
+    results.push({
+      symbolA: target.symbol,
+      shortNameA: shortenSymbol(target.symbol),
+      fileA: target.file,
+      symbolB: candidate.symbol,
+      shortNameB: shortenSymbol(candidate.symbol),
+      fileB: candidate.file,
+      similarity,
+      sharedCallees: [...shared].sort(),
+      uniqueToA: [...difference(target.tokens, candidate.tokens)].sort(),
+      uniqueToB: [...difference(candidate.tokens, target.tokens)].sort()
+    });
+  }
+  results.sort((a, b) => b.similarity - a.similarity || a.shortNameB.localeCompare(b.shortNameB));
+  return results.slice(0, opts.limit);
+}
+function findSourceFingerprint(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match || !isFunctionLikeSymbol(match.symbol)) {
+    return null;
+  }
+  const snippet = definitionSnippet(db, match.relativePath, match.startLine, match.endLine, leafName(match.symbol));
+  const tokens = sourceTokens(snippet, leafName(match.symbol));
+  if (tokens.size === 0) {
+    return null;
+  }
+  return {
+    symbol: match.symbol,
+    file: match.relativePath,
+    tokens
+  };
+}
+function getAllSourceFingerprints(db) {
+  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    tokens: sourceTokens(
+      definitionSnippet(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+      definition.leaf
+    )
+  })).filter((fingerprint) => fingerprint.tokens.size > 0);
+}
+function definitionSnippet(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return "";
+  }
+  const lines = source.split("\n");
+  if (endLine >= startLine && endLine - startLine <= 12) {
+    return lines.slice(startLine, endLine + 1).join("\n");
+  }
+  const markerPatterns = [
+    new RegExp(`\\bdef\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfun\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfn\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfunction\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\b${escapeRegex(leaf)}\\s*\\(`)
+  ];
+  const definitionStart = lines.findIndex((line) => markerPatterns.some((pattern) => pattern.test(line)));
+  if (definitionStart >= 0) {
+    let definitionEnd = definitionStart;
+    for (let index = definitionStart + 1; index < lines.length && index <= definitionStart + 8; index++) {
+      const line = lines[index] ?? "";
+      if (index > definitionStart && looksLikeDefinitionBoundary(line)) {
+        break;
+      }
+      definitionEnd = index;
+      if (line.trim() === "" && index > definitionStart + 1) {
+        break;
+      }
+    }
+    return lines.slice(definitionStart, definitionEnd + 1).join("\n");
+  }
+  return lines.slice(startLine, Math.min(lines.length, startLine + 8)).join("\n");
+}
+function sourceTokens(snippet, leaf) {
+  if (!snippet) {
+    return /* @__PURE__ */ new Set();
+  }
+  const stopWords = /* @__PURE__ */ new Set([
+    "public",
+    "private",
+    "protected",
+    "final",
+    "static",
+    "class",
+    "def",
+    "fun",
+    "fn",
+    "function",
+    "return",
+    "string",
+    "bool",
+    "boolean",
+    "void",
+    "unit",
+    "self",
+    "this",
+    "new",
+    "const",
+    "let",
+    "var",
+    "end",
+    "pub"
+  ]);
+  const normalizedLeafParts = splitIdentifier(leaf);
+  const normalized = snippet.replace(/["'`]/g, " ").replace(/\b\d+\b/g, " NUM ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9_]+/g, " ").replace(/_/g, " ").toLowerCase();
+  const tokens = normalized.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 1).filter((token) => !stopWords.has(token)).filter((token) => !normalizedLeafParts.has(token));
+  return new Set(tokens);
+}
+function splitIdentifier(value) {
+  return new Set(
+    value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9_]+|_/).map((part) => part.toLowerCase()).filter((part) => part.length > 1)
+  );
+}
+function looksLikeDefinitionBoundary(line) {
+  return /^\s*(?:def|fun|fn|function|class|trait|module|object|enum|interface|public|private|protected)\b/.test(line);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 export {
   similar,
   similarAll
 };
-//# sourceMappingURL=chunk-OIDHN6GD.js.map
+//# sourceMappingURL=chunk-I2JM34UV.js.map