unguard 0.10.0 → 0.10.2

package/dist/{chunk-5GVEUYZF.js → chunk-NNUATKJZ.js}

@@ -636,6 +636,7 @@ var preferRequiredParamWithGuard = {
 };
 
 // src/rules/cross-file/duplicate-type-declaration.ts
+import * as ts18 from "typescript";
 var duplicateTypeDeclaration = {
   id: "duplicate-type-declaration",
   severity: "warning",
@@ -645,6 +646,7 @@ var duplicateTypeDeclaration = {
     for (const group of project.types.getDuplicateGroups()) {
       const files = new Set(group.map((e) => e.file));
       if (files.size < 2) continue;
+      if (group.every((e) => isTrivialObjectShape(e.node))) continue;
       reportDuplicateGroup(
         group,
         this.id,
@@ -657,9 +659,14 @@ var duplicateTypeDeclaration = {
     return diagnostics;
   }
 };
+function isTrivialObjectShape(node) {
+  if (ts18.isTypeLiteralNode(node)) return node.members.length <= 1;
+  if (ts18.isInterfaceDeclaration(node)) return node.members.length <= 1;
+  return false;
+}
 
 // src/rules/cross-file/duplicate-function-declaration.ts
-import * as ts18 from "typescript";
+import * as ts19 from "typescript";
 var duplicateFunctionDeclaration = {
   id: "duplicate-function-declaration",
   severity: "warning",
@@ -684,12 +691,13 @@ var duplicateFunctionDeclaration = {
   }
 };
 function getBodyBlock(node) {
-  if (ts18.isFunctionDeclaration(node) || ts18.isFunctionExpression(node)) return node.body;
-  if (ts18.isArrowFunction(node)) return ts18.isBlock(node.body) ? node.body : void 0;
-  if (ts18.isMethodDeclaration(node)) return node.body;
+  if (ts19.isFunctionDeclaration(node) || ts19.isFunctionExpression(node)) return node.body;
+  if (ts19.isArrowFunction(node)) return ts19.isBlock(node.body) ? node.body : void 0;
+  if (ts19.isMethodDeclaration(node)) return node.body;
   return void 0;
 }
 function isSingleStatement(node) {
+  if (ts19.isArrowFunction(node) && !ts19.isBlock(node.body)) return true;
   const body = getBodyBlock(node);
   return body !== void 0 && body.statements.length <= 1;
 }
@@ -697,8 +705,8 @@ function isSetter(node) {
   const body = getBodyBlock(node);
   if (!body || body.statements.length !== 1) return false;
   const stmt = body.statements[0];
-  if (stmt === void 0 || !ts18.isExpressionStatement(stmt)) return false;
-  return ts18.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts18.SyntaxKind.EqualsToken;
+  if (stmt === void 0 || !ts19.isExpressionStatement(stmt)) return false;
+  return ts19.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts19.SyntaxKind.EqualsToken;
 }
 
 // src/rules/cross-file/optional-arg-always-used.ts
@@ -733,14 +741,14 @@ var optionalArgAlwaysUsed = {
 };
 
 // src/rules/ts/no-catch-return.ts
-import * as ts19 from "typescript";
+import * as ts20 from "typescript";
 var noCatchReturn = {
   kind: "ts",
   id: "no-catch-return",
   severity: "warning",
   message: "Catch block silently returns a fallback value with no logging; rethrow, log the error, or let it propagate",
   visit(node, ctx) {
-    if (!ts19.isCatchClause(node)) return;
+    if (!ts20.isCatchClause(node)) return;
     const block = node.block;
     if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
       ctx.report(node);
@@ -750,57 +758,57 @@ var noCatchReturn = {
 function walkBlock(block, predicate) {
   function visit(node) {
     if (predicate(node)) return true;
-    if (ts19.isFunctionDeclaration(node) || ts19.isFunctionExpression(node) || ts19.isArrowFunction(node)) return false;
-    return ts19.forEachChild(node, visit) ?? false;
+    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return false;
+    return ts20.forEachChild(node, visit) ?? false;
   }
-  return ts19.forEachChild(block, visit) ?? false;
+  return ts20.forEachChild(block, visit) ?? false;
 }
 function hasReturn(block) {
-  return walkBlock(block, (n) => ts19.isReturnStatement(n));
+  return walkBlock(block, (n) => ts20.isReturnStatement(n));
 }
 function hasThrow(block) {
-  return walkBlock(block, (n) => ts19.isThrowStatement(n));
+  return walkBlock(block, (n) => ts20.isThrowStatement(n));
 }
 var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
 function hasLogging(block) {
   return walkBlock(block, (n) => {
-    if (!ts19.isCallExpression(n)) return false;
+    if (!ts20.isCallExpression(n)) return false;
     const callee = n.expression;
-    if (!ts19.isPropertyAccessExpression(callee)) return false;
-    if (!ts19.isIdentifier(callee.expression)) return false;
+    if (!ts20.isPropertyAccessExpression(callee)) return false;
+    if (!ts20.isIdentifier(callee.expression)) return false;
     return LOG_OBJECTS.has(callee.expression.text);
   });
 }
 
 // src/rules/ts/no-error-rewrap.ts
-import * as ts20 from "typescript";
+import * as ts21 from "typescript";
 var noErrorRewrap = {
   kind: "ts",
   id: "no-error-rewrap",
   severity: "error",
   message: "Re-wrapped error loses the original stack trace and type; use { cause: originalError } to preserve the error chain",
   visit(node, ctx) {
-    if (!ts20.isCatchClause(node)) return;
+    if (!ts21.isCatchClause(node)) return;
     if (!node.variableDeclaration) return;
     const param = node.variableDeclaration.name;
-    if (!ts20.isIdentifier(param)) return;
+    if (!ts21.isIdentifier(param)) return;
     const catchName = param.text;
     findRewraps(node.block, catchName, ctx);
   }
 };
 function findRewraps(block, catchName, ctx) {
   function visit(node) {
-    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return;
-    if (ts20.isThrowStatement(node) && node.expression && ts20.isNewExpression(node.expression)) {
+    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return;
+    if (ts21.isThrowStatement(node) && node.expression && ts21.isNewExpression(node.expression)) {
       const args = node.expression.arguments;
       if (args && args.length > 0 && referencesName(args, catchName) && !hasCauseArg(args)) {
         ctx.report(node);
       }
       return;
     }
-    ts20.forEachChild(node, visit);
+    ts21.forEachChild(node, visit);
   }
-  ts20.forEachChild(block, visit);
+  ts21.forEachChild(block, visit);
 }
 function referencesName(args, name) {
   for (const arg of args) {
@@ -809,15 +817,15 @@ function referencesName(args, name) {
   return false;
 }
 function containsIdentifier(node, name) {
-  if (ts20.isIdentifier(node) && node.text === name) return true;
-  return ts20.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+  if (ts21.isIdentifier(node) && node.text === name) return true;
+  return ts21.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
 }
 function hasCauseArg(args) {
   for (const arg of args) {
-    if (ts20.isObjectLiteralExpression(arg)) {
+    if (ts21.isObjectLiteralExpression(arg)) {
       for (const prop of arg.properties) {
-        if (ts20.isPropertyAssignment(prop) && ts20.isIdentifier(prop.name) && prop.name.text === "cause") return true;
-        if (ts20.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
+        if (ts21.isPropertyAssignment(prop) && ts21.isIdentifier(prop.name) && prop.name.text === "cause") return true;
+        if (ts21.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
       }
     }
   }
@@ -825,7 +833,7 @@ function hasCauseArg(args) {
 }
 
 // src/rules/cross-file/explicit-null-arg.ts
-import * as ts21 from "typescript";
+import * as ts22 from "typescript";
 var explicitNullArg = {
   id: "explicit-null-arg",
   severity: "warning",
@@ -845,7 +853,7 @@ var explicitNullArg = {
         const arg = site.node.arguments[i];
         if (arg === void 0) continue;
         if (isNullishLiteral(arg)) {
-          const val = arg.kind === ts21.SyntaxKind.NullKeyword ? "null" : "undefined";
+          const val = arg.kind === ts22.SyntaxKind.NullKeyword ? "null" : "undefined";
           diagnostics.push({
             ruleId: this.id,
             severity: this.severity,
@@ -918,7 +926,7 @@ function resolveCandidates(fromFile, specifier) {
 }
 
 // src/rules/cross-file/duplicate-type-name.ts
-import * as ts22 from "typescript";
+import * as ts23 from "typescript";
 var duplicateTypeName = {
   id: "duplicate-type-name",
   severity: "warning",
@@ -929,7 +937,7 @@ var duplicateTypeName = {
       const hashes = new Set(group.map((e) => e.hash));
       if (hashes.size === 1) continue;
       const hasInferredType = group.some(
-        (e) => !ts22.isTypeLiteralNode(e.node) && !ts22.isInterfaceDeclaration(e.node)
+        (e) => !ts23.isTypeLiteralNode(e.node) && !ts23.isInterfaceDeclaration(e.node)
       );
       if (hasInferredType) continue;
       reportDuplicateGroup(
@@ -969,20 +977,21 @@ var duplicateConstantDeclaration = {
 };
 
 // src/rules/ts/no-dynamic-import.ts
-import * as ts23 from "typescript";
+import * as ts24 from "typescript";
 var noDynamicImport = {
   kind: "ts",
   id: "no-dynamic-import",
   severity: "error",
   message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
   visit(node, ctx) {
-    if (!ts23.isCallExpression(node)) return;
-    if (node.expression.kind !== ts23.SyntaxKind.ImportKeyword) return;
+    if (!ts24.isCallExpression(node)) return;
+    if (node.expression.kind !== ts24.SyntaxKind.ImportKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/cross-file/near-duplicate-function.ts
+import * as ts25 from "typescript";
 var nearDuplicateFunction = {
   id: "near-duplicate-function",
   severity: "warning",
@@ -992,6 +1001,7 @@ var nearDuplicateFunction = {
     for (const group of project.functions.getNearDuplicateGroups()) {
       const MIN_NORMALIZED_BODY = 32;
       if (group.every((e) => e.normalizedBodyLength < MIN_NORMALIZED_BODY)) continue;
+      if (group.every(isSimpleStructure)) continue;
       reportDuplicateGroup(
         group,
         this.id,
@@ -1004,38 +1014,67 @@ var nearDuplicateFunction = {
     return diagnostics;
   }
 };
+function getFunctionBody(node) {
+  if (ts25.isFunctionDeclaration(node) || ts25.isFunctionExpression(node)) return node.body;
+  if (ts25.isArrowFunction(node)) return node.body;
+  if (ts25.isMethodDeclaration(node)) return node.body;
+  return void 0;
+}
+function getTopLevelStatementCount(body) {
+  if (ts25.isBlock(body)) return body.statements.length;
+  return 1;
+}
+function hasControlFlow(node) {
+  let found = false;
+  function visit(current) {
+    if (found) return;
+    if (ts25.isIfStatement(current) || ts25.isSwitchStatement(current) || ts25.isTryStatement(current) || ts25.isForStatement(current) || ts25.isForInStatement(current) || ts25.isForOfStatement(current) || ts25.isWhileStatement(current) || ts25.isDoStatement(current)) {
+      found = true;
+      return;
+    }
+    ts25.forEachChild(current, visit);
+  }
+  visit(node);
+  return found;
+}
+function isSimpleStructure(entry) {
+  const body = getFunctionBody(entry.node);
+  if (!body) return false;
+  if (hasControlFlow(body)) return false;
+  return getTopLevelStatementCount(body) <= 2;
+}
 
 // src/rules/cross-file/trivial-wrapper.ts
-import * as ts24 from "typescript";
-function getFunctionBody(node) {
-  if (ts24.isFunctionDeclaration(node) || ts24.isFunctionExpression(node)) {
+import * as ts26 from "typescript";
+function getFunctionBody2(node) {
+  if (ts26.isFunctionDeclaration(node) || ts26.isFunctionExpression(node)) {
     return node.body;
   }
-  if (ts24.isArrowFunction(node)) {
+  if (ts26.isArrowFunction(node)) {
     return node.body;
   }
-  if (ts24.isMethodDeclaration(node)) {
+  if (ts26.isMethodDeclaration(node)) {
     return node.body;
   }
   return void 0;
 }
 function getCalleeName(expr) {
-  if (ts24.isIdentifier(expr)) return expr.text;
-  if (ts24.isPropertyAccessExpression(expr)) return expr.name.text;
+  if (ts26.isIdentifier(expr)) return expr.text;
+  if (ts26.isPropertyAccessExpression(expr)) return expr.name.text;
   return void 0;
 }
 function getTrivialCallTarget(fn) {
-  const body = getFunctionBody(fn.node);
+  const body = getFunctionBody2(fn.node);
   if (!body) return null;
   let callExpr;
-  if (ts24.isBlock(body)) {
+  if (ts26.isBlock(body)) {
     if (body.statements.length !== 1) return null;
     const stmt = body.statements[0];
-    if (!stmt || !ts24.isReturnStatement(stmt) || !stmt.expression) return null;
-    if (!ts24.isCallExpression(stmt.expression)) return null;
+    if (!stmt || !ts26.isReturnStatement(stmt) || !stmt.expression) return null;
+    if (!ts26.isCallExpression(stmt.expression)) return null;
     callExpr = stmt.expression;
   } else {
-    if (!ts24.isCallExpression(body)) return null;
+    if (!ts26.isCallExpression(body)) return null;
     callExpr = body;
   }
   const calleeName = getCalleeName(callExpr.expression);
@@ -1043,7 +1082,7 @@ function getTrivialCallTarget(fn) {
   const paramNames = fn.params.map((p) => p.name);
   const args = callExpr.arguments;
   for (const arg of args) {
-    if (!ts24.isIdentifier(arg)) return null;
+    if (!ts26.isIdentifier(arg)) return null;
     if (!paramNames.includes(arg.text)) return null;
   }
   return { calleeName };
@@ -1340,32 +1379,32 @@ function isFailOn(value) {
 }
 
 // src/collect/index.ts
-import * as ts27 from "typescript";
+import * as ts29 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts25 from "typescript";
+import * as ts27 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 (ts25.isTypeLiteralNode(node)) {
+  if (ts27.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts25.isInterfaceDeclaration(node)) {
+  if (ts27.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts25.isPropertySignature(node)) {
+  if (ts27.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 (ts25.isTypeAliasDeclaration(node)) {
+  if (ts27.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
@@ -1531,7 +1570,7 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts26 from "typescript";
+import * as ts28 from "typescript";
 function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
   return {
     filename,
@@ -1539,7 +1578,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
     sourceFile,
     checker,
     report(node, message) {
-      const { line, character } = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1550,7 +1589,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts26.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1576,7 +1615,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
 }
 
 // src/collect/index.ts
-function collectProject(program, tsRules) {
+function collectProject(program, tsRules, allowedFiles) {
   const checker = program.getTypeChecker();
   const types = new TypeRegistry();
   const functions = new FunctionRegistry();
@@ -1601,12 +1640,13 @@ function collectProject(program, tsRules) {
           rule.visit(node, ctx);
         }
       }
-      ts27.forEachChild(node, visit2);
+      ts29.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
     if (sourceFile.isDeclarationFile) continue;
     if (file.includes("node_modules")) continue;
+    if (allowedFiles && !allowedFiles.has(file)) continue;
     const source = sourceFile.getFullText();
     const comments = collectAllComments(sourceFile);
     fileMap.set(file, { source, sourceFile, comments });
@@ -1614,7 +1654,7 @@ function collectProject(program, tsRules) {
       rule,
       ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
     }));
-    ts27.forEachChild(sourceFile, visit2);
+    ts29.forEachChild(sourceFile, visit2);
   }
   const fileHashes = /* @__PURE__ */ new Map();
   for (const [file, { source }] of fileMap) {
@@ -1630,52 +1670,52 @@ function collectProject(program, tsRules) {
   return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
 }
 function hasNonPublicModifier(node) {
-  if (!ts27.canHaveModifiers(node)) return false;
-  const mods = ts27.getModifiers(node);
+  if (!ts29.canHaveModifiers(node)) return false;
+  const mods = ts29.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts27.SyntaxKind.PrivateKeyword || m.kind === ts27.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts29.SyntaxKind.PrivateKeyword || m.kind === ts29.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts27.canHaveModifiers(node)) return false;
-  const mods = ts27.getModifiers(node);
+  if (!ts29.canHaveModifiers(node)) return false;
+  const mods = ts29.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts27.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts29.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts27.isTypeAliasDeclaration(node)) {
-    const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts29.isTypeAliasDeclaration(node)) {
+    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts27.isInterfaceDeclaration(node)) {
-    const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts29.isInterfaceDeclaration(node)) {
+    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  if (ts27.isStringLiteral(node)) return true;
-  if (ts27.isNumericLiteral(node)) return true;
-  if (ts27.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts27.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
-  if (ts27.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  if (ts29.isStringLiteral(node)) return true;
+  if (ts29.isNumericLiteral(node)) return true;
+  if (ts29.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts29.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts29.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts27.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts27.NodeFlags.Const)) return;
+  if (!ts29.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts29.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts27.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts29.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 = ts27.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts29.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 = ts27.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const line = ts29.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
   const hash = hashFunctionBody(body, sourceFile);
@@ -1697,17 +1737,17 @@ function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name,
   };
 }
 function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts27.isFunctionDeclaration(node) && node.name && node.body) {
+  if (ts29.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 (ts27.isVariableStatement(node)) {
+  if (ts29.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts27.isArrowFunction(decl.initializer) && ts27.isIdentifier(decl.name)) {
+      if (decl.initializer && ts29.isArrowFunction(decl.initializer) && ts29.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
@@ -1715,7 +1755,7 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
           node: arrow
         }));
       }
-      if (decl.initializer && ts27.isFunctionExpression(decl.initializer) && ts27.isIdentifier(decl.name)) {
+      if (decl.initializer && ts29.isFunctionExpression(decl.initializer) && ts29.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
@@ -1727,22 +1767,22 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts27.isPropertyAssignment(node) && (ts27.isIdentifier(node.name) || ts27.isStringLiteral(node.name))) {
+  if (ts29.isPropertyAssignment(node) && (ts29.isIdentifier(node.name) || ts29.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts27.isArrowFunction(init)) {
+    if (ts29.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts27.isFunctionExpression(init) && init.body) {
+    if (ts29.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts27.isArrowFunction(node) || ts27.isFunctionExpression(node)) {
+  if (ts29.isArrowFunction(node) || ts29.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts27.isVariableDeclaration(parent) && ts27.isIdentifier(parent.name)) {
-    } else if (ts27.isPropertyAssignment(parent)) {
+    if (ts29.isVariableDeclaration(parent) && ts29.isIdentifier(parent.name)) {
+    } else if (ts29.isPropertyAssignment(parent)) {
     } else {
-      const body = ts27.isArrowFunction(node) ? node.body : node.body;
+      const body = ts29.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
         if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
@@ -1752,14 +1792,14 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts27.isMethodDeclaration(node) && node.body && ts27.isIdentifier(node.name)) {
+  if (ts29.isMethodDeclaration(node) && node.body && ts29.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts27.isClassDeclaration(parent)) {
+    if (ts29.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 === ts27.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts29.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
@@ -1782,16 +1822,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts27.isCallExpression(parent)) {
+  const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts29.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts27.isPropertyAssignment(grandparent) && ts27.isIdentifier(grandparent.name)) {
+    if (ts29.isPropertyAssignment(grandparent) && ts29.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts27.isIdentifier(parent.expression)) {
+    if (ts29.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts27.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts29.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -1802,7 +1842,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts27.isImportDeclaration(node) && ts27.isStringLiteral(node.moduleSpecifier)) {
+  if (ts29.isImportDeclaration(node) && ts29.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -1814,7 +1854,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts27.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts29.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -1825,9 +1865,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts27.isExportDeclaration(node) && node.moduleSpecifier && ts27.isStringLiteral(node.moduleSpecifier)) {
+  if (ts29.isExportDeclaration(node) && node.moduleSpecifier && ts29.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts27.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts29.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -1840,7 +1880,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts27.isBlock(node)) return;
+  if (!ts29.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -1857,34 +1897,34 @@ function collectStatementSequences(node, file, sourceFile, registry) {
       const firstStmt = window[0];
       const lastStmt = window[window.length - 1];
       if (firstStmt === void 0 || lastStmt === void 0) continue;
-      const line = ts27.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts27.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts29.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts29.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 (!ts27.isTypeLiteralNode(node)) return;
+  if (!ts29.isTypeLiteralNode(node)) return;
   const parent = node.parent;
-  if (!parent || !ts27.isParameter(parent)) return;
+  if (!parent || !ts29.isParameter(parent)) return;
   if (parent.type !== node) return;
-  const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts27.isCallExpression(node)) return;
+  if (!ts29.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts27.isIdentifier(node.expression)) {
+  if (ts29.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts27.isPropertyAccessExpression(node.expression)) {
+  } else if (ts29.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts27.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts29.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
     } catch {
@@ -1904,12 +1944,12 @@ function collectAllComments(sourceFile) {
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
   function visit(node) {
-    const leading = ts27.getLeadingCommentRanges(source, node.getFullStart());
+    const leading = ts29.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 === ts27.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts29.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1918,12 +1958,12 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    const trailing = ts27.getTrailingCommentRanges(source, node.getEnd());
+    const trailing = ts29.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 === ts27.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts29.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1932,34 +1972,34 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    ts27.forEachChild(node, visit);
+    ts29.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts28 from "typescript";
+import * as ts30 from "typescript";
 import { dirname as dirname2 } from "path";
 function createProgramFromFiles(files) {
   let configPath;
   if (files.length > 0) {
-    configPath = ts28.findConfigFile(dirname2(files[0]), ts28.sys.fileExists, "tsconfig.json");
+    configPath = ts30.findConfigFile(dirname2(files[0]), ts30.sys.fileExists, "tsconfig.json");
   }
   if (configPath) {
-    const configFile = ts28.readConfigFile(configPath, ts28.sys.readFile);
-    const parsed = ts28.parseJsonConfigFileContent(configFile.config, ts28.sys, dirname2(configPath));
-    return ts28.createProgram({
+    const configFile = ts30.readConfigFile(configPath, ts30.sys.readFile);
+    const parsed = ts30.parseJsonConfigFileContent(configFile.config, ts30.sys, dirname2(configPath));
+    return ts30.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts28.createProgram({
+  return ts30.createProgram({
     rootNames: files,
     options: {
-      target: ts28.ScriptTarget.ESNext,
-      module: ts28.ModuleKind.ESNext,
-      moduleResolution: ts28.ModuleResolutionKind.Bundler,
+      target: ts30.ScriptTarget.ESNext,
+      module: ts30.ModuleKind.ESNext,
+      moduleResolution: ts30.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -1973,7 +2013,8 @@ function analyzeFiles(files, rules) {
   const crossFileRules = rules.filter((r) => !isTSRule(r));
   const program = files.length > 0 ? createProgramFromFiles(files) : null;
   if (!program) return [];
-  const { index, diagnostics } = collectProject(program, tsRules);
+  const allowedFiles = new Set(files);
+  const { index, diagnostics } = collectProject(program, tsRules, allowedFiles);
   for (const rule of crossFileRules) {
     const crossDiagnostics = rule.analyze(index);
     for (const diagnostic of crossDiagnostics) {
@@ -2198,4 +2239,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-5GVEUYZF.js.map
+//# sourceMappingURL=chunk-NNUATKJZ.js.map