unguard 0.11.0 → 0.12.0

package/README.md

@@ -165,6 +165,7 @@ These rules use the TypeScript type checker. Non-nullable types suppress the dia
 | `unused-export` | info | Exported function with no usages in the project |
 | `optional-arg-always-used` | warning | Optional param provided at every call site |
 | `explicit-null-arg` | warning | `fn(null)` / `fn(undefined)` to project functions |
+| `dead-overload` | warning | Overload signature with zero matching project call sites |
 
 ### Imports
 

package/dist/{chunk-ZNOFYNU4.js → chunk-HE647T6E.js}

@@ -1304,6 +1304,177 @@ var duplicateStatementSequence = {
   }
 };
 
+// src/rules/cross-file/dead-overload.ts
+import * as ts28 from "typescript";
+var deadOverload = {
+  id: "dead-overload",
+  severity: "warning",
+  message: "Overload signature has no matching call sites in the project",
+  analyze(project) {
+    const diagnostics = [];
+    for (const [file, { sourceFile }] of project.files) {
+      for (const family of collectOverloadFamilies(sourceFile, file)) {
+        const matchedOverloads = /* @__PURE__ */ new Set();
+        for (const site of project.callSites) {
+          const declaration = site.resolvedDeclaration;
+          if (declaration === void 0) continue;
+          if (family.overloads.includes(declaration)) {
+            matchedOverloads.add(declaration);
+          }
+        }
+        if (matchedOverloads.size === 0) continue;
+        const deadOverloads = family.overloads.filter((overload) => !matchedOverloads.has(overload));
+        const liveOverloads = family.overloads.filter((overload) => matchedOverloads.has(overload));
+        for (const overload of deadOverloads) {
+          diagnostics.push({
+            ruleId: this.id,
+            severity: this.severity,
+            message: buildMessage(family, overload, deadOverloads, liveOverloads),
+            file,
+            line: lineOf(sourceFile, overload),
+            column: 1
+          });
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+function buildMessage(family, overload, deadOverloads, liveOverloads) {
+  const base = `Overload signature for "${family.name}" has no matching call sites in the project`;
+  if (!shouldMentionCascade(family, overload, deadOverloads, liveOverloads)) {
+    return base;
+  }
+  return `${base}; removing it may let you collapse to the remaining constrained signature and drop implementation casts`;
+}
+function shouldMentionCascade(family, overload, deadOverloads, liveOverloads) {
+  if (deadOverloads.length !== 1 || liveOverloads.length !== 1) return false;
+  if (deadOverloads[0] !== overload) return false;
+  const liveOverload = liveOverloads[0];
+  if (liveOverload === void 0) return false;
+  if (family.implementation.typeParameters === void 0 || liveOverload.typeParameters === void 0) return false;
+  const body = family.implementation.body;
+  if (body === void 0) return false;
+  const implementationTypeParams = family.implementation.typeParameters;
+  const liveTypeParams = liveOverload.typeParameters;
+  if (implementationTypeParams.length === 0 || implementationTypeParams.length !== liveTypeParams.length) return false;
+  const constrainedParams = implementationTypeParams.flatMap((typeParam, index) => {
+    const liveTypeParam = liveTypeParams[index];
+    if (liveTypeParam === void 0) return [];
+    if (typeParam.constraint !== void 0) return [];
+    if (liveTypeParam.constraint === void 0) return [];
+    return [{
+      paramName: typeParam.name.text,
+      constraintText: normalizeText(liveTypeParam.constraint.getText(family.sourceFile))
+    }];
+  });
+  if (constrainedParams.length === 0) return false;
+  return constrainedParams.some(
+    ({ paramName, constraintText }) => hasIntersectionCast(body, family.sourceFile, paramName, constraintText)
+  );
+}
+function hasIntersectionCast(body, sourceFile, paramName, constraintText) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts28.isAsExpression(node) || ts28.isTypeAssertionExpression(node)) {
+      if (isConstraintIntersection(node.type, sourceFile, paramName, constraintText)) {
+        found = true;
+        return;
+      }
+    }
+    ts28.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function isConstraintIntersection(typeNode, sourceFile, paramName, constraintText) {
+  const target = unwrapParenthesizedType(typeNode);
+  if (!ts28.isIntersectionTypeNode(target)) return false;
+  let hasParam = false;
+  let hasConstraint = false;
+  for (const part of target.types) {
+    const text = normalizeText(unwrapParenthesizedType(part).getText(sourceFile));
+    if (text === paramName) hasParam = true;
+    if (text === constraintText) hasConstraint = true;
+  }
+  return hasParam && hasConstraint;
+}
+function unwrapParenthesizedType(typeNode) {
+  let current = typeNode;
+  while (ts28.isParenthesizedTypeNode(current)) {
+    current = current.type;
+  }
+  return current;
+}
+function collectOverloadFamilies(sourceFile, file) {
+  const families = [];
+  collectFromList(sourceFile.statements, sourceFile, file, families);
+  function visit(node) {
+    if (ts28.isClassDeclaration(node) || ts28.isClassExpression(node)) {
+      collectFromList(node.members, sourceFile, file, families);
+    }
+    ts28.forEachChild(node, visit);
+  }
+  ts28.forEachChild(sourceFile, visit);
+  return families;
+}
+function collectFromList(nodes, sourceFile, file, families) {
+  for (let index = 0; index < nodes.length; index++) {
+    const current = asOverloadDeclaration(nodes[index]);
+    const name = current ? getDeclarationName(current) : null;
+    if (current === null || name === null) continue;
+    const run = [current];
+    let nextIndex = index + 1;
+    while (nextIndex < nodes.length) {
+      const next = asOverloadDeclaration(nodes[nextIndex]);
+      if (next === null) break;
+      if (getDeclarationName(next) !== name) break;
+      run.push(next);
+      nextIndex++;
+    }
+    const family = toOverloadFamily(run, name, file, sourceFile);
+    if (family !== null) {
+      families.push(family);
+    }
+    index = nextIndex - 1;
+  }
+}
+function toOverloadFamily(run, name, file, sourceFile) {
+  if (run.length < 2) return null;
+  const implementation = run.at(-1);
+  if (implementation === void 0 || implementation.body === void 0) return null;
+  if (run.slice(0, -1).some((declaration) => declaration.body !== void 0)) return null;
+  return {
+    name,
+    file,
+    sourceFile,
+    overloads: run.slice(0, -1),
+    implementation
+  };
+}
+function asOverloadDeclaration(node) {
+  if (node === void 0) return null;
+  if (ts28.isFunctionDeclaration(node)) return node;
+  if (ts28.isMethodDeclaration(node)) return node;
+  return null;
+}
+function getDeclarationName(node) {
+  if (ts28.isFunctionDeclaration(node)) {
+    return node.name?.text ?? null;
+  }
+  if (ts28.isIdentifier(node.name) || ts28.isStringLiteral(node.name) || ts28.isNumericLiteral(node.name)) {
+    return node.name.text;
+  }
+  return null;
+}
+function lineOf(sourceFile, node) {
+  return ts28.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+}
+function normalizeText(text) {
+  return text.replace(/\s+/g, "");
+}
+
 // src/rules/index.ts
 var allRules = [
   noEmptyCatch,
@@ -1338,7 +1509,8 @@ var allRules = [
   trivialWrapper,
   unusedExport,
   duplicateFile,
-  duplicateStatementSequence
+  duplicateStatementSequence,
+  deadOverload
 ];
 var ruleMetadata = {
   "no-any-cast": { category: "type-evasion", tags: ["safety"] },
@@ -1373,7 +1545,8 @@ var ruleMetadata = {
   "trivial-wrapper": { category: "cross-file", tags: ["duplicate"] },
   "unused-export": { category: "cross-file", tags: ["api"] },
   "duplicate-file": { category: "cross-file", tags: ["duplicate"] },
-  "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] }
+  "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] },
+  "dead-overload": { category: "cross-file", tags: ["api", "type-evasion"] }
 };
 function getRuleMetadata(ruleId) {
   const metadata = ruleMetadata[ruleId];
@@ -1433,32 +1606,32 @@ function isFailOn(value) {
 }
 
 // src/collect/index.ts
-import * as ts30 from "typescript";
+import * as ts31 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts28 from "typescript";
+import * as ts29 from "typescript";
 function hashTypeShape(node, sourceFile) {
   const normalized = normalizeTypeNode(node, sourceFile);
   return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function normalizeTypeNode(node, sourceFile) {
-  if (ts28.isTypeLiteralNode(node)) {
+  if (ts29.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts28.isInterfaceDeclaration(node)) {
+  if (ts29.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts28.isPropertySignature(node)) {
+  if (ts29.isPropertySignature(node)) {
     const keyName = node.name.getText(sourceFile);
     const optional = node.questionToken ? "?" : "";
     const type = node.type ? normalizeTypeNode(node.type, sourceFile) : "any";
     return `${keyName}${optional}:${type}`;
   }
-  if (ts28.isTypeAliasDeclaration(node)) {
+  if (ts29.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
@@ -1491,7 +1664,7 @@ function normalizeBody(node, sourceFile, paramNames) {
   text = text.replace(/\s+/g, " ").trim();
   return text;
 }
-function normalizeText(text) {
+function normalizeText2(text) {
   let t = text.replace(/\/\/[^\n]*/g, "");
   t = t.replace(/\/\*[\s\S]*?\*\//g, "");
   t = t.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
@@ -1624,7 +1797,7 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts29 from "typescript";
+import * as ts30 from "typescript";
 function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
   return {
     filename,
@@ -1632,7 +1805,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
     sourceFile,
     checker,
     report(node, message) {
-      const { line, character } = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1643,7 +1816,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts29.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1694,7 +1867,7 @@ function collectProject(program, tsRules, allowedFiles) {
           rule.visit(node, ctx);
         }
       }
-      ts30.forEachChild(node, visit2);
+      ts31.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
@@ -1708,7 +1881,7 @@ function collectProject(program, tsRules, allowedFiles) {
       rule,
       ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
     }));
-    ts30.forEachChild(sourceFile, visit2);
+    ts31.forEachChild(sourceFile, visit2);
   }
   const fileHashes = /* @__PURE__ */ new Map();
   for (const [file, { source }] of fileMap) {
@@ -1724,52 +1897,52 @@ function collectProject(program, tsRules, allowedFiles) {
   return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
 }
 function hasNonPublicModifier(node) {
-  if (!ts30.canHaveModifiers(node)) return false;
-  const mods = ts30.getModifiers(node);
+  if (!ts31.canHaveModifiers(node)) return false;
+  const mods = ts31.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts30.SyntaxKind.PrivateKeyword || m.kind === ts30.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts31.SyntaxKind.PrivateKeyword || m.kind === ts31.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts30.canHaveModifiers(node)) return false;
-  const mods = ts30.getModifiers(node);
+  if (!ts31.canHaveModifiers(node)) return false;
+  const mods = ts31.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts30.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts31.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts30.isTypeAliasDeclaration(node)) {
-    const line = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isTypeAliasDeclaration(node)) {
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts30.isInterfaceDeclaration(node)) {
-    const line = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isInterfaceDeclaration(node)) {
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  if (ts30.isStringLiteral(node)) return true;
-  if (ts30.isNumericLiteral(node)) return true;
-  if (ts30.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts30.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
-  if (ts30.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  if (ts31.isStringLiteral(node)) return true;
+  if (ts31.isNumericLiteral(node)) return true;
+  if (ts31.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts31.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts31.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts30.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts30.NodeFlags.Const)) return;
+  if (!ts31.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts31.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts30.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts31.isIdentifier(decl.name)) continue;
     if (!isConstantValue(decl.initializer)) continue;
     const valueText = decl.initializer.getText(sourceFile).replace(/\s+/g, " ").trim();
     const valueHash = createHash2("sha256").update(valueText).digest("hex").slice(0, 16);
-    const line = ts30.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
     registry.add({ name: decl.name.text, file, line, valueHash, valueText, exported });
   }
 }
 function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name, extra) {
-  const line = ts30.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
   const hash = hashFunctionBody(body, sourceFile);
@@ -1791,17 +1964,17 @@ function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name,
   };
 }
 function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts30.isFunctionDeclaration(node) && node.name && node.body) {
+  if (ts31.isFunctionDeclaration(node) && node.name && node.body) {
     registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, node.name.text, {
       exported: isExported(node),
       symbol: checker.getSymbolAtLocation(node.name),
       node
     }));
   }
-  if (ts30.isVariableStatement(node)) {
+  if (ts31.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts30.isArrowFunction(decl.initializer) && ts30.isIdentifier(decl.name)) {
+      if (decl.initializer && ts31.isArrowFunction(decl.initializer) && ts31.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
@@ -1809,7 +1982,7 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
           node: arrow
         }));
       }
-      if (decl.initializer && ts30.isFunctionExpression(decl.initializer) && ts30.isIdentifier(decl.name)) {
+      if (decl.initializer && ts31.isFunctionExpression(decl.initializer) && ts31.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
@@ -1821,22 +1994,22 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts30.isPropertyAssignment(node) && (ts30.isIdentifier(node.name) || ts30.isStringLiteral(node.name))) {
+  if (ts31.isPropertyAssignment(node) && (ts31.isIdentifier(node.name) || ts31.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts30.isArrowFunction(init)) {
+    if (ts31.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts30.isFunctionExpression(init) && init.body) {
+    if (ts31.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts30.isArrowFunction(node) || ts30.isFunctionExpression(node)) {
+  if (ts31.isArrowFunction(node) || ts31.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts30.isVariableDeclaration(parent) && ts30.isIdentifier(parent.name)) {
-    } else if (ts30.isPropertyAssignment(parent)) {
+    if (ts31.isVariableDeclaration(parent) && ts31.isIdentifier(parent.name)) {
+    } else if (ts31.isPropertyAssignment(parent)) {
     } else {
-      const body = ts30.isArrowFunction(node) ? node.body : node.body;
+      const body = ts31.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
         if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
@@ -1846,14 +2019,14 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts30.isMethodDeclaration(node) && node.body && ts30.isIdentifier(node.name)) {
+  if (ts31.isMethodDeclaration(node) && node.body && ts31.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts30.isClassDeclaration(parent)) {
+    if (ts31.isClassDeclaration(parent)) {
       if (hasNonPublicModifier(node)) return;
       const className = parent.name ? parent.name.text : "<anonymous>";
       const name = `${className}.${node.name.text}`;
       const implementsInterface = parent.heritageClauses?.some(
-        (c) => c.token === ts30.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts31.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
@@ -1876,16 +2049,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts30.isCallExpression(parent)) {
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts30.isPropertyAssignment(grandparent) && ts30.isIdentifier(grandparent.name)) {
+    if (ts31.isPropertyAssignment(grandparent) && ts31.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts30.isIdentifier(parent.expression)) {
+    if (ts31.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts30.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts31.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -1896,7 +2069,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts30.isImportDeclaration(node) && ts30.isStringLiteral(node.moduleSpecifier)) {
+  if (ts31.isImportDeclaration(node) && ts31.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -1908,7 +2081,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts30.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts31.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -1919,9 +2092,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts30.isExportDeclaration(node) && node.moduleSpecifier && ts30.isStringLiteral(node.moduleSpecifier)) {
+  if (ts31.isExportDeclaration(node) && node.moduleSpecifier && ts31.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts30.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts31.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -1934,7 +2107,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts30.isBlock(node)) return;
+  if (!ts31.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -1944,43 +2117,46 @@ function collectStatementSequences(node, file, sourceFile, registry) {
       const window = stmts.slice(start, start + size);
       const texts = window.map((s) => s.getText(sourceFile));
       const joined = texts.join("\n");
-      const normalized = normalizeText(joined);
+      const normalized = normalizeText2(joined);
       if (normalized.length < 128) continue;
       const hash = hashText(joined.replace(/\s+/g, " ").trim());
       const normalizedHash = hashText(normalized);
       const firstStmt = window[0];
       const lastStmt = window[window.length - 1];
       if (firstStmt === void 0 || lastStmt === void 0) continue;
-      const line = ts30.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts30.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts31.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts31.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
       registry.add({ file, line, endLine, hash, normalizedHash, statementCount: size, normalizedBodyLength: normalized.length });
     }
   }
 }
 function collectInlineParamTypes(node, file, sourceFile, registry) {
-  if (!ts30.isTypeLiteralNode(node)) return;
+  if (!ts31.isTypeLiteralNode(node)) return;
   const parent = node.parent;
-  if (!parent || !ts30.isParameter(parent)) return;
+  if (!parent || !ts31.isParameter(parent)) return;
   if (parent.type !== node) return;
-  const line = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts30.isCallExpression(node)) return;
+  if (!ts31.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts30.isIdentifier(node.expression)) {
+  if (ts31.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts30.isPropertyAccessExpression(node.expression)) {
+  } else if (ts31.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
+    let resolvedDeclaration;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts30.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts31.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
+      const signature = checker.getResolvedSignature(node);
+      resolvedDeclaration = signature?.declaration;
     } catch {
     }
     sites.push({
@@ -1989,7 +2165,8 @@ function collectCallSites(node, file, sourceFile, checker, sites) {
       line,
       argCount: node.arguments.length,
       node,
-      symbol
+      symbol,
+      resolvedDeclaration
     });
   }
 }
@@ -1998,12 +2175,12 @@ function collectAllComments(sourceFile) {
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
   function visit(node) {
-    const leading = ts30.getLeadingCommentRanges(source, node.getFullStart());
+    const leading = ts31.getLeadingCommentRanges(source, node.getFullStart());
     if (leading) {
       for (const r of leading) {
         if (seen.has(r.pos)) continue;
         seen.add(r.pos);
-        const isLine = r.kind === ts30.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts31.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -2012,12 +2189,12 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    const trailing = ts30.getTrailingCommentRanges(source, node.getEnd());
+    const trailing = ts31.getTrailingCommentRanges(source, node.getEnd());
     if (trailing) {
       for (const r of trailing) {
         if (seen.has(r.pos)) continue;
         seen.add(r.pos);
-        const isLine = r.kind === ts30.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts31.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -2026,34 +2203,34 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    ts30.forEachChild(node, visit);
+    ts31.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts31 from "typescript";
+import * as ts32 from "typescript";
 import { dirname as dirname2 } from "path";
 function createProgramFromFiles(files) {
   let configPath;
   if (files.length > 0) {
-    configPath = ts31.findConfigFile(dirname2(files[0]), ts31.sys.fileExists, "tsconfig.json");
+    configPath = ts32.findConfigFile(dirname2(files[0]), ts32.sys.fileExists, "tsconfig.json");
   }
   if (configPath) {
-    const configFile = ts31.readConfigFile(configPath, ts31.sys.readFile);
-    const parsed = ts31.parseJsonConfigFileContent(configFile.config, ts31.sys, dirname2(configPath));
-    return ts31.createProgram({
+    const configFile = ts32.readConfigFile(configPath, ts32.sys.readFile);
+    const parsed = ts32.parseJsonConfigFileContent(configFile.config, ts32.sys, dirname2(configPath));
+    return ts32.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts31.createProgram({
+  return ts32.createProgram({
     rootNames: files,
     options: {
-      target: ts31.ScriptTarget.ESNext,
-      module: ts31.ModuleKind.ESNext,
-      moduleResolution: ts31.ModuleResolutionKind.Bundler,
+      target: ts32.ScriptTarget.ESNext,
+      module: ts32.ModuleKind.ESNext,
+      moduleResolution: ts32.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -2293,4 +2470,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-ZNOFYNU4.js.map
+//# sourceMappingURL=chunk-HE647T6E.js.map