@decantr/verifier 3.1.0 → 3.4.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/index.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync, statSync as statSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync6, realpathSync as realpathSync2, statSync as statSync5 } from "fs";
 import { readFile } from "fs/promises";
-import { basename as basename2, dirname, extname as extname4, isAbsolute as isAbsolute2, join as join4, relative as relative4, resolve } from "path";
+import { basename as basename2, dirname as dirname2, extname as extname6, isAbsolute as isAbsolute4, join as join6, relative as relative6, resolve as resolve3 } from "path";
 import { evaluateGuard, isV4, validateEssence } from "@decantr/essence-spec";
-import * as ts3 from "typescript";
+import * as ts6 from "typescript";
 
 // src/component-reuse.ts
 import { readFileSync } from "fs";
@@ -968,6 +968,22 @@ function normalizePath2(path) {
 function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
 }
+function normalizedConfidence(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(1, value));
+}
+function nativeTokenHint(mapping) {
+  const kind = typeof mapping.native?.kind === "string" ? mapping.native.kind : null;
+  const ref = typeof mapping.native?.ref === "string" ? mapping.native.ref : null;
+  if (!kind || !ref) return null;
+  return kind === "css-var" || kind === "vanilla-extract-token" || kind === "sass-var" ? ref : null;
+}
+function nativeClassHint(mapping) {
+  const kind = typeof mapping.native?.kind === "string" ? mapping.native.kind : null;
+  const ref = typeof mapping.native?.ref === "string" ? mapping.native.ref : null;
+  if (!kind || !ref) return null;
+  return kind === "class" || kind === "tailwind-class" || kind === "component" ? ref : null;
+}
 function isNonProductionStyleBridgeDriftFile(file) {
   const normalized = normalizePath2(file);
   return /(?:^|\/)(?:__tests__|__mocks__|tests?|specs?|fixtures?|mocks?|stories?)(?:\/|$)/i.test(
@@ -1022,12 +1038,28 @@ function readAcceptedStyleBridge(projectRoot) {
     (mapping, index) => typeof mapping.id === "string" && mapping.id.length > 0 ? mapping.id : typeof mapping.label === "string" && mapping.label.length > 0 ? mapping.label : `mapping-${index + 1}`
   ).slice(0, 12);
   const tokenHints = [
-    ...new Set(mappings.flatMap((mapping) => stringArray(mapping.tokenHints)))
-  ].slice(0, 16);
+    ...new Set(
+      mappings.flatMap((mapping) => [...stringArray(mapping.tokenHints), nativeTokenHint(mapping)])
+    )
+  ].filter((entry) => Boolean(entry)).slice(0, 16);
   const classHints = [
-    ...new Set(mappings.flatMap((mapping) => stringArray(mapping.classHints)))
+    ...new Set(
+      mappings.flatMap((mapping) => [...stringArray(mapping.classHints), nativeClassHint(mapping)])
+    )
+  ].filter((entry) => Boolean(entry)).slice(0, 16);
+  const confidences = mappings.map((mapping) => normalizedConfidence(mapping.confidence)).filter((entry) => entry !== null);
+  const sources = [
+    ...new Set(
+      mappings.map((mapping) => mapping.source).filter((source) => typeof source === "string" && source.length > 0)
+    )
   ].slice(0, 16);
-  return { mappingIds, tokenHints, classHints };
+  return {
+    mappingIds,
+    confidence: confidences.length > 0 ? Math.max(...confidences) : null,
+    sources,
+    tokenHints,
+    classHints
+  };
 }
 function lineForNode2(sourceFile, node) {
   return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
@@ -1184,11 +1216,15 @@ function collectStyleBridgeDriftFindings(input) {
       source,
       ...property ? { property } : {},
       bridgeMappingIds: input.bridge.mappingIds,
+      bridgeConfidence: input.bridge.confidence,
+      bridgeSources: input.bridge.sources,
       tokenHints: input.bridge.tokenHints,
       classHints: input.bridge.classHints,
       evidence: [
         styleBridgeEvidenceText(file, line, source, value),
         `.decantr/style-bridge.json is accepted with mappings: ${input.bridge.mappingIds.join(", ")}`,
+        input.bridge.confidence === null ? "Accepted style bridge has no mapping confidence metadata" : `Accepted style bridge max confidence: ${input.bridge.confidence.toFixed(2)}`,
+        input.bridge.sources.length > 0 ? `Accepted style bridge mapping sources: ${input.bridge.sources.join(", ")}` : "Accepted style bridge has no mapping source metadata",
         input.bridge.tokenHints.length > 0 ? `Accepted token hints: ${input.bridge.tokenHints.join(", ")}` : "Accepted style bridge has no token hints for this mapping set",
         input.bridge.classHints.length > 0 ? `Accepted class hints: ${input.bridge.classHints.join(", ")}` : "Accepted style bridge has no class hints for this mapping set"
       ]
@@ -1265,11 +1301,15 @@ function collectStylesheetBridgeDriftFindings(input) {
         source: "stylesheet",
         property,
         bridgeMappingIds: input.bridge.mappingIds,
+        bridgeConfidence: input.bridge.confidence,
+        bridgeSources: input.bridge.sources,
         tokenHints: input.bridge.tokenHints,
         classHints: input.bridge.classHints,
         evidence: [
           `${file}:${lineNumber} uses stylesheet value "${value}"`,
           `.decantr/style-bridge.json is accepted with mappings: ${input.bridge.mappingIds.join(", ")}`,
+          input.bridge.confidence === null ? "Accepted style bridge has no mapping confidence metadata" : `Accepted style bridge max confidence: ${input.bridge.confidence.toFixed(2)}`,
+          input.bridge.sources.length > 0 ? `Accepted style bridge mapping sources: ${input.bridge.sources.join(", ")}` : "Accepted style bridge has no mapping source metadata",
           input.bridge.tokenHints.length > 0 ? `Accepted token hints: ${input.bridge.tokenHints.join(", ")}` : "Accepted style bridge has no token hints for this mapping set",
           input.bridge.classHints.length > 0 ? `Accepted class hints: ${input.bridge.classHints.join(", ")}` : "Accepted style bridge has no class hints for this mapping set"
         ]
@@ -1324,6 +1364,18 @@ var KNOWN_VERIFICATION_DIAGNOSTICS = [
     repairId: "fix-route-render",
     family: "VISUAL"
   },
+  {
+    rule: "browser-runtime-probes-failed",
+    code: "RUNTIME010",
+    repairId: "repair-browser-runtime-probes",
+    family: "RUNTIME"
+  },
+  {
+    rule: "browser-axe-violations",
+    code: "A11Y020",
+    repairId: "fix-rendered-accessibility",
+    family: "A11Y"
+  },
   {
     rule: "visual-baseline-screenshot-drift",
     code: "VISUAL010",
@@ -2965,6 +3017,716 @@ function resolveGitHubScanInput(input) {
   throw new Error("V1 hosted scans support GitHub repositories and GitHub Pages URLs.");
 }
 
+// src/source/ast.ts
+import * as ts4 from "typescript";
+
+// src/source/inventory.ts
+import { existsSync as existsSync4, readdirSync as readdirSync4, realpathSync, statSync as statSync3 } from "fs";
+import { extname as extname4, isAbsolute as isAbsolute2, join as join4, relative as relative4, resolve } from "path";
+import * as ts3 from "typescript";
+var DEFAULT_MAX_FILES = 5e3;
+var DEFAULT_MAX_FILE_SIZE_BYTES = 512 * 1024;
+var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+var GENERATED_AND_DEPENDENCY_DIRS = /* @__PURE__ */ new Set([
+  ".cache",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".vite",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "target",
+  "vendor"
+]);
+var TEST_OR_MOCK_DIR_RE = /(?:^|\/)(?:__mocks__|__tests__|mocks?|specs?|tests?)(?:\/|$)/i;
+var FIXTURE_DIR_RE = /(?:^|\/)fixtures?(?:\/|$)/i;
+var DECLARATION_FILE_RE = /\.d\.[cm]?ts$/i;
+var TEST_OR_MOCK_FILE_RE = /\.(?:mock|spec|test)\.[cm]?[jt]sx?$/i;
+var STORY_FILE_RE = /\.(?:stories|story)\.[cm]?[jt]sx?$/i;
+var FIXTURE_FILE_RE = /\.fixture\.[cm]?[jt]sx?$/i;
+function normalizeSourcePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isPathInsideProject(projectRoot, absolutePath) {
+  const normalizedRelative = normalizeSourcePath(relative4(projectRoot, absolutePath));
+  return normalizedRelative === "" || !normalizedRelative.startsWith("../") && normalizedRelative !== "..";
+}
+function isSupportedSourceExtension(extension, extensions) {
+  const normalized = extension.toLowerCase();
+  return extensions ? extensions.map((entry) => entry.toLowerCase()).includes(normalized) : DEFAULT_EXTENSIONS.has(normalized);
+}
+function sourceKindFromPath(path) {
+  const extension = extname4(path).toLowerCase();
+  switch (extension) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".mts":
+      return "mts";
+    case ".cts":
+      return "cts";
+    case ".js":
+      return "js";
+    case ".jsx":
+      return "jsx";
+    case ".mjs":
+      return "mjs";
+    case ".cjs":
+      return "cjs";
+    default:
+      return null;
+  }
+}
+function sourceScriptKindFromPath(path) {
+  const kind = sourceKindFromPath(path);
+  switch (kind) {
+    case "ts":
+    case "mts":
+    case "cts":
+      return ts3.ScriptKind.TS;
+    case "tsx":
+      return ts3.ScriptKind.TSX;
+    case "jsx":
+      return ts3.ScriptKind.JSX;
+    case "js":
+    case "mjs":
+    case "cjs":
+      return ts3.ScriptKind.JS;
+    default:
+      return ts3.ScriptKind.Unknown;
+  }
+}
+function sourceLanguageFromPath(path) {
+  const kind = sourceKindFromPath(path);
+  if (!kind) return null;
+  return kind === "ts" || kind === "tsx" || kind === "mts" || kind === "cts" ? "typescript" : "javascript";
+}
+function shouldSkipDirectory(relativePath, options) {
+  const normalized = normalizeSourcePath(relativePath);
+  const basename3 = normalized.split("/").at(-1) ?? normalized;
+  if (GENERATED_AND_DEPENDENCY_DIRS.has(basename3)) return true;
+  if (!options.includeTests && TEST_OR_MOCK_DIR_RE.test(normalized)) return true;
+  if (!options.includeFixtures && FIXTURE_DIR_RE.test(normalized)) return true;
+  return false;
+}
+function shouldSkipFile(relativePath, options) {
+  const normalized = normalizeSourcePath(relativePath);
+  if (DECLARATION_FILE_RE.test(normalized)) return true;
+  if (!options.includeTests && (TEST_OR_MOCK_FILE_RE.test(normalized) || STORY_FILE_RE.test(normalized))) {
+    return true;
+  }
+  if (!options.includeFixtures && FIXTURE_FILE_RE.test(normalized)) return true;
+  return false;
+}
+function inventoryFile(projectRoot, absolutePath) {
+  const extension = extname4(absolutePath).toLowerCase();
+  const kind = sourceKindFromPath(absolutePath);
+  const language = sourceLanguageFromPath(absolutePath);
+  if (!kind || !language) return null;
+  const relativePath = normalizeSourcePath(relative4(projectRoot, absolutePath) || absolutePath);
+  const sizeBytes = statSync3(absolutePath).size;
+  return {
+    absolutePath,
+    relativePath,
+    extension,
+    kind,
+    language,
+    scriptKind: sourceScriptKindFromPath(absolutePath),
+    jsx: kind === "tsx" || kind === "jsx",
+    sizeBytes
+  };
+}
+function compareSourceFiles(a, b) {
+  return a.relativePath.localeCompare(b.relativePath);
+}
+function compareSkipped(a, b) {
+  return a.path.localeCompare(b.path) || a.reason.localeCompare(b.reason);
+}
+function createSourceInventory(projectRoot, options = {}) {
+  const root = realpathSync(resolve(projectRoot));
+  const files = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  const skipped = [];
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const maxFileSizeBytes = options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+  const requestedRoots = options.roots?.length ? [...options.roots] : ["."];
+  const roots = requestedRoots.map((entry) => isAbsolute2(entry) ? resolve(entry) : resolve(root, entry)).filter((entry) => existsSync4(entry) && isPathInsideProject(root, entry));
+  const addSkipped = (path, reason) => {
+    skipped.push({ path: normalizeSourcePath(relative4(root, path) || path), reason });
+  };
+  const addFile = (absolutePath) => {
+    const normalized = normalizeSourcePath(resolve(absolutePath));
+    if (seenFiles.has(normalized)) return;
+    const sourceFile = inventoryFile(root, absolutePath);
+    if (!sourceFile) return;
+    seenFiles.add(normalized);
+    files.push(sourceFile);
+  };
+  const walk = (directory) => {
+    if (files.length >= maxFiles) {
+      addSkipped(directory, "walk-limit");
+      return;
+    }
+    const entries = readdirSync4(directory, { withFileTypes: true }).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+    for (const entry of entries) {
+      if (files.length >= maxFiles) {
+        addSkipped(join4(directory, entry.name), "walk-limit");
+        continue;
+      }
+      const absolutePath = join4(directory, entry.name);
+      const relativePath = normalizeSourcePath(relative4(root, absolutePath) || absolutePath);
+      if (entry.isSymbolicLink()) {
+        addSkipped(absolutePath, "symlink");
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (shouldSkipDirectory(relativePath, options)) {
+          addSkipped(absolutePath, "ignored-directory");
+          continue;
+        }
+        walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const extension = extname4(entry.name).toLowerCase();
+      if (!isSupportedSourceExtension(extension, options.extensions)) continue;
+      if (shouldSkipFile(relativePath, options)) {
+        addSkipped(absolutePath, "ignored-file");
+        continue;
+      }
+      const stat = statSync3(absolutePath);
+      if (stat.size > maxFileSizeBytes) {
+        addSkipped(absolutePath, "oversized");
+        continue;
+      }
+      addFile(absolutePath);
+    }
+  };
+  for (const rootPath of roots) {
+    if (files.length >= maxFiles) {
+      addSkipped(rootPath, "walk-limit");
+      continue;
+    }
+    const stat = statSync3(rootPath);
+    if (stat.isDirectory()) {
+      const relativeRoot = normalizeSourcePath(relative4(root, rootPath));
+      if (relativeRoot && shouldSkipDirectory(relativeRoot, options)) {
+        addSkipped(rootPath, "ignored-directory");
+        continue;
+      }
+      walk(rootPath);
+    } else if (stat.isFile()) {
+      const extension = extname4(rootPath).toLowerCase();
+      if (!isSupportedSourceExtension(extension, options.extensions)) continue;
+      const relativeFile = normalizeSourcePath(relative4(root, rootPath));
+      if (shouldSkipFile(relativeFile, options)) {
+        addSkipped(rootPath, "ignored-file");
+        continue;
+      }
+      addFile(rootPath);
+    }
+  }
+  const sortedFiles = files.sort(compareSourceFiles);
+  const hasTypeScript = sortedFiles.some((file) => file.language === "typescript");
+  const hasJavaScript = sortedFiles.some((file) => file.language === "javascript");
+  return {
+    projectRoot: root,
+    files: sortedFiles,
+    skipped: skipped.sort(compareSkipped),
+    hasTypeScript,
+    hasJavaScript,
+    primaryLanguage: hasTypeScript && hasJavaScript ? "mixed" : hasTypeScript ? "typescript" : hasJavaScript ? "javascript" : "unknown"
+  };
+}
+
+// src/source/ast.ts
+function sourceLocationForNode(sourceFile, node) {
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return {
+    file: normalizeSourcePath(sourceFile.fileName),
+    line: position.line + 1,
+    column: position.character + 1
+  };
+}
+function literalRawText(node) {
+  return node.getText();
+}
+function isStringLiteralLike(node) {
+  return ts4.isStringLiteral(node) || ts4.isNoSubstitutionTemplateLiteral(node);
+}
+function isImportSpecifierLiteral(node) {
+  const parent = node.parent;
+  return ts4.isImportDeclaration(parent) && parent.moduleSpecifier === node || ts4.isExternalModuleReference(parent) && parent.expression === node;
+}
+function isExportSpecifierLiteral(node) {
+  const parent = node.parent;
+  return ts4.isExportDeclaration(parent) && parent.moduleSpecifier === node;
+}
+function requireOrDynamicImportContext(node) {
+  const parent = node.parent;
+  if (!ts4.isCallExpression(parent) || parent.arguments[0] !== node) return null;
+  if (parent.expression.kind === ts4.SyntaxKind.ImportKeyword) return "dynamic-import-specifier";
+  if (ts4.isIdentifier(parent.expression) && parent.expression.text === "require") {
+    return "require-specifier";
+  }
+  return null;
+}
+function propertyNameContext(node) {
+  const parent = node.parent;
+  if ((ts4.isPropertyAssignment(parent) || ts4.isPropertyDeclaration(parent) || ts4.isMethodDeclaration(parent) || ts4.isGetAccessorDeclaration(parent) || ts4.isSetAccessorDeclaration(parent)) && parent.name === node) {
+    return "property-name";
+  }
+  return null;
+}
+function jsxAttributeContext(node) {
+  const parent = node.parent;
+  if (!ts4.isJsxAttribute(parent) || parent.initializer !== node) return null;
+  return {
+    context: "jsx-attribute",
+    attributeName: parent.name.getText()
+  };
+}
+function literalContext(node) {
+  const jsxContext = jsxAttributeContext(node);
+  if (jsxContext) return jsxContext;
+  const importLikeContext = requireOrDynamicImportContext(node);
+  if (importLikeContext) return { context: importLikeContext };
+  if (isImportSpecifierLiteral(node)) return { context: "import-specifier" };
+  if (isExportSpecifierLiteral(node)) return { context: "export-specifier" };
+  const propertyContext = propertyNameContext(node);
+  if (propertyContext) return { context: propertyContext };
+  return {
+    context: ts4.isNoSubstitutionTemplateLiteral(node) ? "template-literal" : "string-literal"
+  };
+}
+function extractSourceStringLiterals(sourceFile, options = {}) {
+  const includeImportSpecifiers = options.includeImportSpecifiers ?? true;
+  const includeObjectPropertyNames = options.includeObjectPropertyNames ?? true;
+  const literals = [];
+  const visit = (node) => {
+    if (isStringLiteralLike(node)) {
+      const context = literalContext(node);
+      const isImportLike = context.context === "import-specifier" || context.context === "export-specifier" || context.context === "require-specifier" || context.context === "dynamic-import-specifier";
+      if ((includeImportSpecifiers || !isImportLike) && (includeObjectPropertyNames || context.context !== "property-name")) {
+        literals.push({
+          value: node.text,
+          rawText: literalRawText(node),
+          context: context.context,
+          location: sourceLocationForNode(sourceFile, node),
+          ...context.attributeName ? { attributeName: context.attributeName } : {}
+        });
+      }
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return literals;
+}
+
+// src/source/program.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { dirname, extname as extname5, isAbsolute as isAbsolute3, join as join5, relative as relative5, resolve as resolve2 } from "path";
+import * as ts5 from "typescript";
+var RESOLUTION_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var DEFAULT_COMPILER_OPTIONS = {
+  allowImportingTsExtensions: true,
+  allowJs: true,
+  allowSyntheticDefaultImports: true,
+  checkJs: false,
+  esModuleInterop: true,
+  jsx: ts5.JsxEmit.ReactJSX,
+  module: ts5.ModuleKind.ESNext,
+  moduleResolution: ts5.ModuleResolutionKind.Bundler,
+  noEmit: true,
+  resolveJsonModule: true,
+  skipLibCheck: true,
+  target: ts5.ScriptTarget.ES2022
+};
+function findProjectTsConfig(projectRoot, tsconfigPath) {
+  if (tsconfigPath === null) return null;
+  if (tsconfigPath) {
+    const absolutePath = isAbsolute3(tsconfigPath) ? resolve2(tsconfigPath) : resolve2(projectRoot, tsconfigPath);
+    return existsSync5(absolutePath) ? absolutePath : null;
+  }
+  const localTsConfig = join5(projectRoot, "tsconfig.json");
+  return existsSync5(localTsConfig) ? localTsConfig : null;
+}
+function fallbackCompilerConfig(tsconfigPath, options, diagnostics = []) {
+  return {
+    tsconfigPath,
+    compilerOptions: {
+      ...DEFAULT_COMPILER_OPTIONS,
+      ...options.compilerOptions,
+      allowJs: true,
+      noEmit: true,
+      skipLibCheck: true
+    },
+    diagnostics
+  };
+}
+function readCompilerConfig(projectRoot, options) {
+  const tsconfigPath = findProjectTsConfig(projectRoot, options.tsconfigPath);
+  if (!tsconfigPath) return fallbackCompilerConfig(null, options);
+  const parsedJson = ts5.parseConfigFileTextToJson(
+    tsconfigPath,
+    readFileSync5(tsconfigPath, "utf-8")
+  );
+  if (parsedJson.error) return fallbackCompilerConfig(tsconfigPath, options, [parsedJson.error]);
+  const parsed = ts5.parseJsonConfigFileContent(
+    parsedJson.config,
+    ts5.sys,
+    dirname(tsconfigPath),
+    DEFAULT_COMPILER_OPTIONS,
+    tsconfigPath
+  );
+  return {
+    tsconfigPath,
+    compilerOptions: {
+      ...DEFAULT_COMPILER_OPTIONS,
+      ...parsed.options,
+      ...options.compilerOptions,
+      allowJs: true,
+      noEmit: true,
+      skipLibCheck: true
+    },
+    diagnostics: parsed.errors
+  };
+}
+function inventoryFileByAbsolutePath(inventory) {
+  return new Map(
+    inventory.files.map((file) => [normalizeSourcePath(resolve2(file.absolutePath)), file])
+  );
+}
+function createProjectSourceProgram(projectRoot, options = {}) {
+  const inventory = createSourceInventory(projectRoot, options);
+  const config = readCompilerConfig(inventory.projectRoot, options);
+  const host = ts5.createCompilerHost(config.compilerOptions, true);
+  const program = ts5.createProgram({
+    rootNames: inventory.files.map((file) => file.absolutePath),
+    options: config.compilerOptions,
+    host
+  });
+  return {
+    projectRoot: inventory.projectRoot,
+    tsconfigPath: config.tsconfigPath,
+    inventory,
+    program,
+    compilerOptions: config.compilerOptions,
+    diagnostics: [...config.diagnostics, ...program.getOptionsDiagnostics()]
+  };
+}
+function getProjectSourceFile(context, pathOrSourceFile) {
+  if (typeof pathOrSourceFile !== "string") return pathOrSourceFile;
+  const absolutePath = isAbsolute3(pathOrSourceFile) ? resolve2(pathOrSourceFile) : resolve2(context.projectRoot, pathOrSourceFile);
+  const normalized = normalizeSourcePath(absolutePath);
+  return context.program.getSourceFiles().find((sourceFile) => normalizeSourcePath(resolve2(sourceFile.fileName)) === normalized);
+}
+function sourceFileRelativePath(context, sourceFile) {
+  return normalizeSourcePath(
+    relative5(context.projectRoot, sourceFile.fileName) || sourceFile.fileName
+  );
+}
+function sourceLocationLineAndColumn(sourceFile, node) {
+  const location = sourceLocationForNode(sourceFile, node);
+  return { line: location.line, column: location.column };
+}
+function bindingNames(name) {
+  if (ts5.isIdentifier(name)) return [name.text];
+  return name.elements.flatMap((element) => {
+    if (ts5.isOmittedExpression(element)) return [];
+    return bindingNames(element.name);
+  });
+}
+function importSourceText(node) {
+  if ((ts5.isImportDeclaration(node) || ts5.isExportDeclaration(node)) && node.moduleSpecifier && ts5.isStringLiteral(node.moduleSpecifier)) {
+    return node.moduleSpecifier.text;
+  }
+  if (ts5.isImportEqualsDeclaration(node) && ts5.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression && ts5.isStringLiteral(node.moduleReference.expression)) {
+    return node.moduleReference.expression.text;
+  }
+  if (ts5.isCallExpression(node) && node.arguments.length > 0 && ts5.isStringLiteral(node.arguments[0])) {
+    if (node.expression.kind === ts5.SyntaxKind.ImportKeyword) return node.arguments[0].text;
+    if (ts5.isIdentifier(node.expression) && node.expression.text === "require") {
+      return node.arguments[0].text;
+    }
+  }
+  return null;
+}
+function hasExternalPackageShape(specifier) {
+  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("#");
+}
+function manualResolutionCandidates(context, importerPath, specifier) {
+  const candidates = [];
+  const addCandidates = (base) => {
+    candidates.push(base);
+    if (extname5(base)) return;
+    for (const extension of RESOLUTION_EXTENSIONS) candidates.push(`${base}${extension}`);
+    for (const extension of RESOLUTION_EXTENSIONS) {
+      candidates.push(join5(base, `index${extension}`));
+    }
+  };
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    const base = specifier.startsWith("/") ? resolve2(context.projectRoot, specifier.slice(1)) : resolve2(dirname(importerPath), specifier);
+    addCandidates(base);
+  } else if (specifier.startsWith("@/")) {
+    addCandidates(resolve2(context.projectRoot, specifier.slice(2)));
+    addCandidates(resolve2(context.projectRoot, "src", specifier.slice(2)));
+  }
+  return candidates;
+}
+function resolveFromInventory(context, source, importerPath) {
+  const inventoryByPath = inventoryFileByAbsolutePath(context.inventory);
+  for (const candidate of manualResolutionCandidates(context, importerPath, source)) {
+    const absolutePath = normalizeSourcePath(resolve2(candidate));
+    const inventoryFile2 = inventoryByPath.get(absolutePath);
+    if (!inventoryFile2 || !existsSync5(inventoryFile2.absolutePath) || !statSync4(inventoryFile2.absolutePath).isFile()) {
+      continue;
+    }
+    return {
+      source,
+      importer: normalizeSourcePath(relative5(context.projectRoot, importerPath) || importerPath),
+      kind: "project-local",
+      resolvedFileName: inventoryFile2.absolutePath,
+      relativePath: inventoryFile2.relativePath,
+      extension: inventoryFile2.extension,
+      isProjectLocal: true,
+      isExternal: false,
+      failed: false
+    };
+  }
+  return null;
+}
+function resolveSourceImport(context, importer, source) {
+  const sourceFile = getProjectSourceFile(context, importer);
+  const importerPath = sourceFile ? resolve2(sourceFile.fileName) : isAbsolute3(String(importer)) ? resolve2(String(importer)) : resolve2(context.projectRoot, String(importer));
+  const importerRelativePath = normalizeSourcePath(
+    relative5(context.projectRoot, importerPath) || importerPath
+  );
+  const inventoryByPath = inventoryFileByAbsolutePath(context.inventory);
+  const resolved = ts5.resolveModuleName(
+    source,
+    importerPath,
+    context.compilerOptions,
+    ts5.sys
+  ).resolvedModule;
+  if (resolved) {
+    const absolutePath = normalizeSourcePath(resolve2(resolved.resolvedFileName));
+    const inventoryFile2 = inventoryByPath.get(absolutePath);
+    if (inventoryFile2 && isPathInsideProject(context.projectRoot, absolutePath)) {
+      return {
+        source,
+        importer: importerRelativePath,
+        kind: "project-local",
+        resolvedFileName: inventoryFile2.absolutePath,
+        relativePath: inventoryFile2.relativePath,
+        extension: inventoryFile2.extension,
+        isProjectLocal: true,
+        isExternal: false,
+        failed: false
+      };
+    }
+    return {
+      source,
+      importer: importerRelativePath,
+      kind: hasExternalPackageShape(source) ? "external" : "unresolved",
+      resolvedFileName: resolved.resolvedFileName,
+      relativePath: null,
+      extension: extname5(resolved.resolvedFileName).toLowerCase() || null,
+      isProjectLocal: false,
+      isExternal: hasExternalPackageShape(source),
+      failed: !hasExternalPackageShape(source)
+    };
+  }
+  const fallback = resolveFromInventory(context, source, importerPath);
+  if (fallback) return fallback;
+  return {
+    source,
+    importer: importerRelativePath,
+    kind: hasExternalPackageShape(source) ? "external" : "unresolved",
+    resolvedFileName: null,
+    relativePath: null,
+    extension: null,
+    isProjectLocal: false,
+    isExternal: hasExternalPackageShape(source),
+    failed: !hasExternalPackageShape(source)
+  };
+}
+function importReferenceBase(context, sourceFile, node, source, kind, localNames, imported = [], extra = {}) {
+  const location = sourceLocationLineAndColumn(sourceFile, node);
+  return {
+    file: sourceFileRelativePath(context, sourceFile),
+    source,
+    kind,
+    line: location.line,
+    column: location.column,
+    imported,
+    localNames,
+    typeOnly: extra.typeOnly ?? false,
+    resolved: resolveSourceImport(context, sourceFile, source),
+    ...extra.defaultImport ? { defaultImport: extra.defaultImport } : {},
+    ...extra.namespaceImport ? { namespaceImport: extra.namespaceImport } : {}
+  };
+}
+function collectSourceImports(context, pathOrSourceFile) {
+  const sourceFile = getProjectSourceFile(context, pathOrSourceFile);
+  if (!sourceFile) return [];
+  const imports = [];
+  const visit = (node) => {
+    if (ts5.isImportDeclaration(node)) {
+      const source = importSourceText(node);
+      if (source) {
+        const imported = [];
+        const localNames = [];
+        let defaultImport;
+        let namespaceImport;
+        let typeOnly = node.importClause?.isTypeOnly ?? false;
+        if (node.importClause?.name) {
+          defaultImport = node.importClause.name.text;
+          localNames.push(defaultImport);
+        }
+        const namedBindings = node.importClause?.namedBindings;
+        if (namedBindings && ts5.isNamedImports(namedBindings)) {
+          for (const element of namedBindings.elements) {
+            imported.push((element.propertyName ?? element.name).text);
+            localNames.push(element.name.text);
+            typeOnly ||= element.isTypeOnly;
+          }
+        } else if (namedBindings && ts5.isNamespaceImport(namedBindings)) {
+          namespaceImport = namedBindings.name.text;
+          localNames.push(namespaceImport);
+        }
+        imports.push(
+          importReferenceBase(
+            context,
+            sourceFile,
+            node,
+            source,
+            "static-import",
+            localNames,
+            imported,
+            {
+              ...defaultImport ? { defaultImport } : {},
+              ...namespaceImport ? { namespaceImport } : {},
+              typeOnly
+            }
+          )
+        );
+      }
+    } else if (ts5.isExportDeclaration(node)) {
+      const source = importSourceText(node);
+      if (source) {
+        const exported = node.exportClause && ts5.isNamedExports(node.exportClause) ? node.exportClause.elements.map(
+          (element) => (element.propertyName ?? element.name).text
+        ) : [];
+        imports.push(
+          importReferenceBase(context, sourceFile, node, source, "re-export", [], exported, {
+            typeOnly: node.isTypeOnly
+          })
+        );
+      }
+    } else if (ts5.isImportEqualsDeclaration(node)) {
+      const source = importSourceText(node);
+      if (source) {
+        imports.push(
+          importReferenceBase(context, sourceFile, node, source, "import-equals", [node.name.text])
+        );
+      }
+    } else if (ts5.isCallExpression(node)) {
+      const source = importSourceText(node);
+      if (source) {
+        const kind = node.expression.kind === ts5.SyntaxKind.ImportKeyword ? "dynamic-import" : "require";
+        const parent = node.parent;
+        const localNames = ts5.isVariableDeclaration(parent) && parent.initializer === node ? bindingNames(parent.name) : [];
+        imports.push(importReferenceBase(context, sourceFile, node, source, kind, localNames));
+      }
+    }
+    ts5.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return imports;
+}
+function findImportedFrom(identifier) {
+  let node = identifier;
+  while (node) {
+    if (ts5.isImportDeclaration(node) || ts5.isExportDeclaration(node) || ts5.isImportEqualsDeclaration(node)) {
+      const source = importSourceText(node);
+      return {
+        ...source ? { importSource: source } : {},
+        importedFrom: ts5.SyntaxKind[node.kind]
+      };
+    }
+    node = node.parent;
+  }
+  return {};
+}
+function preferImportBinding(a, b) {
+  if (!a) return b;
+  const aImport = Boolean(findImportedFrom(a).importSource);
+  const bImport = Boolean(findImportedFrom(b).importSource);
+  if (aImport === bImport) return a;
+  return bImport ? b : a;
+}
+function findIdentifier(sourceFile, name, position) {
+  let matched = null;
+  const visit = (node) => {
+    if (matched && position !== void 0) return;
+    if (ts5.isIdentifier(node) && node.text === name) {
+      if (position === void 0) {
+        matched = preferImportBinding(matched, node);
+      } else if (node.getStart(sourceFile) <= position && position <= node.getEnd()) {
+        matched = node;
+        return;
+      }
+    }
+    ts5.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return matched;
+}
+function declarationKind(declaration) {
+  return ts5.SyntaxKind[declaration.kind] ?? "Declaration";
+}
+function resolveSourceSymbolOrigin(context, pathOrSourceFile, localName, options = {}) {
+  const sourceFile = getProjectSourceFile(context, pathOrSourceFile);
+  if (!sourceFile) return null;
+  const identifier = findIdentifier(sourceFile, localName, options.position);
+  if (!identifier) return null;
+  const checker = context.program.getTypeChecker();
+  const symbol = checker.getSymbolAtLocation(identifier);
+  if (!symbol) return null;
+  const originSymbol = symbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  const declarations = originSymbol.declarations ?? symbol.declarations ?? [];
+  if (declarations.length === 0) return null;
+  const projectFiles = inventoryFileByAbsolutePath(context.inventory);
+  const declaration = declarations.find(
+    (entry) => projectFiles.has(normalizeSourcePath(resolve2(entry.getSourceFile().fileName)))
+  ) ?? declarations[0];
+  const declarationFile = declaration.getSourceFile();
+  const declarationPath = normalizeSourcePath(resolve2(declarationFile.fileName));
+  const projectFile = projectFiles.get(declarationPath);
+  const isProjectLocal = Boolean(projectFile);
+  if (!isProjectLocal && !options.includeExternal) return null;
+  const imported = findImportedFrom(identifier);
+  return {
+    name: originSymbol.getName(),
+    localName,
+    file: projectFile?.relativePath ?? normalizeSourcePath(declarationFile.fileName),
+    absolutePath: projectFile?.absolutePath ?? declarationPath,
+    location: sourceLocationForNode(declarationFile, declaration),
+    declarationKind: declarationKind(declaration),
+    isProjectLocal,
+    ...imported
+  };
+}
+
 // src/index.ts
 var VERIFICATION_SCHEMA_URLS = {
   common: "https://decantr.ai/schemas/verification-report.common.v1.json",
@@ -2982,16 +3744,16 @@ function hashString(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
 function hashFile(path) {
-  if (!existsSync4(path)) return null;
+  if (!existsSync6(path)) return null;
   try {
-    return createHash("sha256").update(readFileSync5(path)).digest("hex");
+    return createHash("sha256").update(readFileSync6(path)).digest("hex");
   } catch {
     return null;
   }
 }
 function provenanceEntry(projectRoot, relativePath) {
-  const path = join4(projectRoot, relativePath);
-  if (!existsSync4(path)) {
+  const path = join6(projectRoot, relativePath);
+  if (!existsSync6(path)) {
     return {
       path: relativePath,
       present: false,
@@ -3001,7 +3763,7 @@ function provenanceEntry(projectRoot, relativePath) {
   }
   let generatedAt = null;
   try {
-    generatedAt = statSync3(path).mtime.toISOString();
+    generatedAt = statSync5(path).mtime.toISOString();
   } catch {
     generatedAt = null;
   }
@@ -3013,7 +3775,7 @@ function provenanceEntry(projectRoot, relativePath) {
   };
 }
 function provenanceForPath(projectRoot, path) {
-  const rel = isAbsolute2(path) ? relative4(projectRoot, path).replace(/\\/g, "/") : path;
+  const rel = isAbsolute4(path) ? relative6(projectRoot, path).replace(/\\/g, "/") : path;
   return provenanceEntry(projectRoot, rel && !rel.startsWith("..") ? rel : basename2(path));
 }
 function redactEvidenceText(projectRoot, value) {
@@ -3150,7 +3912,7 @@ function createContractAssertions(projectRoot, audit) {
   const assertions = [];
   const essence = audit?.essence;
   const v4 = essence && isV4(essence) ? essence : null;
-  const contextDir = join4(projectRoot, ".decantr", "context");
+  const contextDir = join6(projectRoot, ".decantr", "context");
   const packManifest = audit?.packManifest ?? null;
   assertions.push(
     assertion({
@@ -3160,7 +3922,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "essence-present",
       status: essence ? "passed" : "failed",
       message: essence ? "Decantr Essence contract is present." : "No Decantr Essence contract was found.",
-      evidence: [redactEvidenceText(projectRoot, join4(projectRoot, "decantr.essence.json"))],
+      evidence: [redactEvidenceText(projectRoot, join6(projectRoot, "decantr.essence.json"))],
       suggestedFix: essence ? void 0 : "Run `decantr init` or restore decantr.essence.json."
     })
   );
@@ -3232,7 +3994,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "pack-manifest-present",
       status: packManifest ? "passed" : "failed",
       message: packManifest ? "Compiled execution pack manifest is present." : "Compiled execution pack manifest is missing.",
-      evidence: [redactEvidenceText(projectRoot, join4(contextDir, "pack-manifest.json"))],
+      evidence: [redactEvidenceText(projectRoot, join6(contextDir, "pack-manifest.json"))],
       suggestedFix: packManifest ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate the full context pack bundle."
     })
   );
@@ -3244,21 +4006,21 @@ function createContractAssertions(projectRoot, audit) {
       rule: "review-pack-present",
       status: audit?.reviewPack ? "passed" : "failed",
       message: audit?.reviewPack ? "Compiled review pack is present." : "Compiled review pack is missing.",
-      evidence: [redactEvidenceText(projectRoot, join4(contextDir, "review-pack.json"))],
+      evidence: [redactEvidenceText(projectRoot, join6(contextDir, "review-pack.json"))],
       suggestedFix: audit?.reviewPack ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` so critique has the compiled review contract."
     })
   );
-  const tokensPath = join4(projectRoot, "src", "styles", "tokens.css");
+  const tokensPath = join6(projectRoot, "src", "styles", "tokens.css");
   assertions.push(
     assertion({
       id: "contract.design-token.tokens-file",
       category: "design-token",
-      severity: existsSync4(tokensPath) ? "info" : "warn",
+      severity: existsSync6(tokensPath) ? "info" : "warn",
       rule: "tokens-file-present",
-      status: existsSync4(tokensPath) ? "passed" : "failed",
-      message: existsSync4(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
+      status: existsSync6(tokensPath) ? "passed" : "failed",
+      message: existsSync6(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
       evidence: [redactEvidenceText(projectRoot, tokensPath)],
-      suggestedFix: existsSync4(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
+      suggestedFix: existsSync6(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
     })
   );
   return assertions;
@@ -3267,9 +4029,9 @@ function createEvidenceBundle(input) {
   const assertions = input.assertions ?? createContractAssertions(input.projectRoot, input.audit);
   let resolvedProjectRoot = input.projectRoot;
   try {
-    resolvedProjectRoot = realpathSync(input.projectRoot);
+    resolvedProjectRoot = realpathSync2(input.projectRoot);
   } catch {
-    resolvedProjectRoot = resolve(input.projectRoot);
+    resolvedProjectRoot = resolve3(input.projectRoot);
   }
   const projectId = `project_${hashString(resolvedProjectRoot)}`;
   return {
@@ -3371,21 +4133,21 @@ function scoreRatio(numerator, denominator) {
   return Math.min(5, Math.max(1, Math.round(numerator / denominator * 5)));
 }
 function readJsonIfExists(path) {
-  if (!existsSync4(path)) return null;
+  if (!existsSync6(path)) return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function loadReviewPack(projectRoot) {
   return readJsonIfExists(
-    join4(projectRoot, ".decantr", "context", "review-pack.json")
+    join6(projectRoot, ".decantr", "context", "review-pack.json")
   );
 }
 function loadPackManifest(projectRoot) {
   return readJsonIfExists(
-    join4(projectRoot, ".decantr", "context", "pack-manifest.json")
+    join6(projectRoot, ".decantr", "context", "pack-manifest.json")
   );
 }
 function collectPackManifestReferences(packManifest) {
@@ -3434,14 +4196,14 @@ function collectPackManifestReferences(packManifest) {
 }
 function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackManifest(projectRoot)) {
   if (!packManifest) return [];
-  const contextDir = join4(projectRoot, ".decantr", "context");
+  const contextDir = join6(projectRoot, ".decantr", "context");
   const missing = [];
   for (const reference of collectPackManifestReferences(packManifest)) {
     for (const field of ["markdown", "json"]) {
       const fileName = reference[field];
       if (!fileName) continue;
-      const absolutePath = join4(contextDir, fileName);
-      if (existsSync4(absolutePath)) continue;
+      const absolutePath = join6(contextDir, fileName);
+      if (existsSync6(absolutePath)) continue;
       missing.push({
         entryId: reference.entryId,
         kind: reference.kind,
@@ -3455,13 +4217,13 @@ function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackMan
 }
 function readTextIfExists(path) {
   try {
-    return existsSync4(path) ? readFileSync5(path, "utf-8") : "";
+    return existsSync6(path) ? readFileSync6(path, "utf-8") : "";
   } catch {
     return "";
   }
 }
 function readProjectAdoptionMode(projectRoot) {
-  const projectJson = readJsonIfExists(join4(projectRoot, ".decantr", "project.json"));
+  const projectJson = readJsonIfExists(join6(projectRoot, ".decantr", "project.json"));
   const adoptionMode = projectJson?.initialized?.adoptionMode;
   return typeof adoptionMode === "string" ? adoptionMode : null;
 }
@@ -3547,7 +4309,7 @@ function collectProjectSourceFiles(projectRoot) {
     "hooks",
     "providers",
     "server"
-  ].map((dir) => join4(projectRoot, dir)).filter((dir) => existsSync4(dir));
+  ].map((dir) => join6(projectRoot, dir)).filter((dir) => existsSync6(dir));
   const rootFileCandidates = [
     "middleware.ts",
     "middleware.tsx",
@@ -3561,7 +4323,7 @@ function collectProjectSourceFiles(projectRoot) {
     "proxy.jsx",
     "proxy.mts",
     "proxy.cts"
-  ].map((file) => join4(projectRoot, file)).filter((file) => existsSync4(file));
+  ].map((file) => join6(projectRoot, file)).filter((file) => existsSync6(file));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -3572,9 +4334,9 @@ function collectProjectSourceFiles(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join4(dir, entry.name);
+      const absolutePath = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -3605,7 +4367,7 @@ function isAuditableStyleFile(filePath) {
   return /\.css$/i.test(filePath);
 }
 function collectProjectStyleFiles2(projectRoot) {
-  const candidates = ["src", "app", "styles"].map((dir) => join4(projectRoot, dir)).filter((dir) => existsSync4(dir));
+  const candidates = ["src", "app", "styles"].map((dir) => join6(projectRoot, dir)).filter((dir) => existsSync6(dir));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -3616,9 +4378,9 @@ function collectProjectStyleFiles2(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join4(dir, entry.name);
+      const absolutePath = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -3646,15 +4408,15 @@ function countReducedMotionSignals(code) {
   return patterns.reduce((count, pattern) => count + (pattern.test(code) ? 1 : 0), 0);
 }
 function hasModuleDirective(filePath, code, directive) {
-  const sourceFile = ts3.createSourceFile(
+  const sourceFile = ts6.createSourceFile(
     filePath,
     code,
-    ts3.ScriptTarget.Latest,
+    ts6.ScriptTarget.Latest,
     true,
     getScriptKind(filePath)
   );
   for (const statement of sourceFile.statements) {
-    if (ts3.isExpressionStatement(statement) && ts3.isStringLiteralLike(statement.expression)) {
+    if (ts6.isExpressionStatement(statement) && ts6.isStringLiteralLike(statement.expression)) {
       if (statement.expression.text === directive) {
         return true;
       }
@@ -3670,20 +4432,20 @@ function importDeclarationHasRuntimeBinding(statement) {
   if (clause.isTypeOnly) return false;
   if (clause.name) return true;
   if (!clause.namedBindings) return true;
-  if (ts3.isNamespaceImport(clause.namedBindings)) return true;
+  if (ts6.isNamespaceImport(clause.namedBindings)) return true;
   return clause.namedBindings.elements.some((element) => !element.isTypeOnly);
 }
 function collectRuntimeImportSpecifiers(entry) {
-  const sourceFile = ts3.createSourceFile(
+  const sourceFile = ts6.createSourceFile(
     entry.relativePath,
     entry.code,
-    ts3.ScriptTarget.Latest,
+    ts6.ScriptTarget.Latest,
     true,
     getScriptKind(entry.relativePath)
   );
   const specifiers = [];
   for (const statement of sourceFile.statements) {
-    if (ts3.isImportDeclaration(statement) && ts3.isStringLiteralLike(statement.moduleSpecifier) && importDeclarationHasRuntimeBinding(statement)) {
+    if (ts6.isImportDeclaration(statement) && ts6.isStringLiteralLike(statement.moduleSpecifier) && importDeclarationHasRuntimeBinding(statement)) {
       specifiers.push(statement.moduleSpecifier.text);
     }
   }
@@ -3692,9 +4454,9 @@ function collectRuntimeImportSpecifiers(entry) {
 function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
   let basePath = null;
   if (specifier.startsWith("@/")) {
-    basePath = join4(projectRoot, "src", specifier.slice(2));
+    basePath = join6(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    basePath = resolve(dirname(sourceAbsolutePath), specifier);
+    basePath = resolve3(dirname2(sourceAbsolutePath), specifier);
   }
   if (!basePath) return null;
   const candidates = [
@@ -3705,14 +4467,14 @@ function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
     `${basePath}.jsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join4(basePath, "index.ts"),
-    join4(basePath, "index.tsx"),
-    join4(basePath, "index.js"),
-    join4(basePath, "index.jsx")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.tsx"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.jsx")
   ];
   for (const candidate of candidates) {
-    if (existsSync4(candidate) && isAuditableSourceFile(candidate)) {
-      return relative4(projectRoot, candidate) || candidate;
+    if (existsSync6(candidate) && isAuditableSourceFile(candidate)) {
+      return relative6(projectRoot, candidate) || candidate;
     }
   }
   return null;
@@ -3760,8 +4522,8 @@ function isClientAuthHeaderSource(relativePath, code, clientReachableFiles) {
 function auditProjectSourceTree(projectRoot, sourceFiles = collectProjectSourceFiles(projectRoot)) {
   const sourceEntries = sourceFiles.map((sourceFile) => ({
     absolutePath: sourceFile,
-    relativePath: relative4(projectRoot, sourceFile) || sourceFile,
-    code: readFileSync5(sourceFile, "utf-8")
+    relativePath: relative6(projectRoot, sourceFile) || sourceFile,
+    code: readFileSync6(sourceFile, "utf-8")
   })).filter((entry) => !isNonProductionSourceAuditFile(entry.relativePath));
   const clientReachableFiles = collectClientReachableSourceFiles(projectRoot, sourceEntries);
   const summary = {
@@ -4074,8 +4836,8 @@ function auditProjectStyleContracts(projectRoot) {
     reducedMotionSignals: createSourceAuditBucket()
   };
   for (const styleFile of styleFiles) {
-    const relativePath = relative4(projectRoot, styleFile) || styleFile;
-    const css = readFileSync5(styleFile, "utf-8");
+    const relativePath = relative6(projectRoot, styleFile) || styleFile;
+    const css = readFileSync6(styleFile, "utf-8");
     recordSourceAudit(summary.focusVisibleSignals, relativePath, countFocusVisibleSignals(css));
     recordSourceAudit(summary.reducedMotionSignals, relativePath, countReducedMotionSignals(css));
   }
@@ -4084,15 +4846,15 @@ function auditProjectStyleContracts(projectRoot) {
 function buildRegistryContext(projectRoot) {
   const themeRegistry = /* @__PURE__ */ new Map();
   const patternRegistry = /* @__PURE__ */ new Map();
-  const cacheDir = join4(projectRoot, ".decantr", "cache");
-  const customDir = join4(projectRoot, ".decantr", "custom");
-  const cachedThemesDir = join4(cacheDir, "@official", "themes");
+  const cacheDir = join6(projectRoot, ".decantr", "cache");
+  const customDir = join6(projectRoot, ".decantr", "custom");
+  const cachedThemesDir = join6(cacheDir, "@official", "themes");
   try {
-    if (existsSync4(cachedThemesDir)) {
-      for (const file of readdirSync4(cachedThemesDir).filter(
+    if (existsSync6(cachedThemesDir)) {
+      for (const file of readdirSync5(cachedThemesDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync5(join4(cachedThemesDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync6(join6(cachedThemesDir, file), "utf-8"));
         if (data.id && !themeRegistry.has(data.id)) {
           themeRegistry.set(data.id, { modes: data.modes || ["light", "dark"] });
         }
@@ -4100,11 +4862,11 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const customThemesDir = join4(customDir, "themes");
+  const customThemesDir = join6(customDir, "themes");
   try {
-    if (existsSync4(customThemesDir)) {
-      for (const file of readdirSync4(customThemesDir).filter((name) => name.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync5(join4(customThemesDir, file), "utf-8"));
+    if (existsSync6(customThemesDir)) {
+      for (const file of readdirSync5(customThemesDir).filter((name) => name.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync6(join6(customThemesDir, file), "utf-8"));
         if (data.id) {
           themeRegistry.set(`custom:${data.id}`, { modes: data.modes || ["light", "dark"] });
         }
@@ -4112,13 +4874,13 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const cachedPatternsDir = join4(cacheDir, "@official", "patterns");
+  const cachedPatternsDir = join6(cacheDir, "@official", "patterns");
   try {
-    if (existsSync4(cachedPatternsDir)) {
-      for (const file of readdirSync4(cachedPatternsDir).filter(
+    if (existsSync6(cachedPatternsDir)) {
+      for (const file of readdirSync5(cachedPatternsDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync5(join4(cachedPatternsDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync6(join6(cachedPatternsDir, file), "utf-8"));
         if (data.id && !patternRegistry.has(data.id)) {
           patternRegistry.set(data.id, data);
         }
@@ -4432,8 +5194,8 @@ function extractFailedRouteDocumentHardening(runtimeAudit) {
   return runtimeAudit.failures.filter((failure) => failure.startsWith("route-document-hardening-failed:")).map((failure) => normalizeRouteHint2(failure.slice("route-document-hardening-failed:".length))).filter(Boolean);
 }
 function appendRuntimeAuditFindings(findings, runtimeAudit, projectRoot, topology, sourceAudit) {
-  const distPath = join4(projectRoot, "dist");
-  const indexPath = join4(distPath, "index.html");
+  const distPath = join6(projectRoot, "dist");
+  const indexPath = join6(distPath, "index.html");
   const isFrameworkBuildOutput = runtimeAudit.failures.includes("next-build-output");
   if (!runtimeAudit.distPresent) {
     findings.push(
@@ -4978,7 +5740,7 @@ function appendRuntimeAuditFindings(findings, runtimeAudit, projectRoot, topolog
 }
 function readBehaviorPatterns(projectRoot) {
   const pack = readJsonIfExists(
-    join4(projectRoot, ".decantr", "local-patterns.json")
+    join6(projectRoot, ".decantr", "local-patterns.json")
   );
   return (pack?.patterns ?? []).filter(
     (pattern) => pattern.behavior_obligations && Array.isArray(pattern.behavior_obligations.obligations) && pattern.behavior_obligations.obligations.length > 0
@@ -5025,15 +5787,15 @@ function isFormPrimitiveDefinitionFile(pattern, relativeFile) {
   );
 }
 function sourceAuditFilePath(projectRoot, file) {
-  return isAbsolute2(file) ? file : join4(projectRoot, file);
+  return isAbsolute4(file) ? file : join6(projectRoot, file);
 }
 function sourceAuditRelativePath(projectRoot, file) {
-  return (isAbsolute2(file) ? relative4(projectRoot, file) : file).replace(/\\/g, "/");
+  return (isAbsolute4(file) ? relative6(projectRoot, file) : file).replace(/\\/g, "/");
 }
 function sourceFileContainsAny(projectRoot, sourceFiles, patterns) {
   for (const file of sourceFiles.slice(0, 400)) {
     try {
-      const code = readFileSync5(sourceAuditFilePath(projectRoot, file), "utf-8");
+      const code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
       if (patterns.some((pattern) => pattern.test(code))) return true;
     } catch {
     }
@@ -5087,7 +5849,7 @@ function appendBehaviorObligationFindings(findings, projectRoot, sourceFiles) {
       const relativeFile = sourceAuditRelativePath(projectRoot, file);
       let code = "";
       try {
-        code = readFileSync5(sourceAuditFilePath(projectRoot, file), "utf-8");
+        code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
       } catch {
         continue;
       }
@@ -5164,7 +5926,7 @@ function appendBehaviorObligationFindings(findings, projectRoot, sourceFiles) {
     const relativeFile = sourceAuditRelativePath(projectRoot, file);
     let code = "";
     try {
-      code = readFileSync5(sourceAuditFilePath(projectRoot, file), "utf-8");
+      code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
     } catch {
       continue;
     }
@@ -6486,6 +7248,8 @@ function appendStyleBridgeDriftFindings(findings, audit) {
             source: finding.source,
             property: finding.property,
             bridge_mappings: finding.bridgeMappingIds,
+            bridge_confidence: finding.bridgeConfidence,
+            bridge_sources: finding.bridgeSources,
             token_hints: finding.tokenHints,
             class_hints: finding.classHints
           }
@@ -6529,7 +7293,7 @@ function appendStyleContractFindings(findings, styleAudit, essence) {
   }
 }
 async function auditProject(projectRoot) {
-  const essencePath = join4(projectRoot, "decantr.essence.json");
+  const essencePath = join6(projectRoot, "decantr.essence.json");
   const findings = [];
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
@@ -6537,7 +7301,7 @@ async function auditProject(projectRoot) {
   const packHydrationOptional = adoptionMode === "contract-only" || adoptionMode === "style-bridge";
   const packHydrationSeverity = packHydrationOptional ? "info" : "warn";
   const runtimeAudit = emptyRuntimeAudit();
-  if (!existsSync4(essencePath)) {
+  if (!existsSync6(essencePath)) {
     findings.push(
       makeFinding({
         id: "essence-missing",
@@ -6572,7 +7336,7 @@ async function auditProject(projectRoot) {
   }
   let essence = null;
   try {
-    essence = JSON.parse(readFileSync5(essencePath, "utf-8"));
+    essence = JSON.parse(readFileSync6(essencePath, "utf-8"));
   } catch (error) {
     findings.push(
       makeFinding({
@@ -6615,7 +7379,7 @@ async function auditProject(projectRoot) {
         category: "Execution Packs",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "Compiled execution pack manifest is not hydrated yet; this is optional for contract-only/style-bridge Brownfield adoption." : "Compiled execution pack manifest is missing.",
-        evidence: [join4(projectRoot, ".decantr", "context", "pack-manifest.json")],
+        evidence: [join6(projectRoot, ".decantr", "context", "pack-manifest.json")],
         suggestedFix: packHydrationOptional ? "Optional: run `decantr registry compile-packs decantr.essence.json --write-context` when you want hosted page packs and review packs for richer assistant context." : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate scaffold, review, mutation, section, and page packs."
       })
     );
@@ -6679,7 +7443,7 @@ async function auditProject(projectRoot) {
         category: "Review Contract",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "The compiled review pack file is not hydrated yet; contract-only/style-bridge Brownfield projects can continue without it." : "The compiled review pack file is missing.",
-        evidence: [join4(projectRoot, ".decantr", "context", "review-pack.json")],
+        evidence: [join6(projectRoot, ".decantr", "context", "review-pack.json")],
         suggestedFix: packHydrationOptional ? "Optional: hydrate hosted packs later if you want critique consumers to anchor findings to the compiled review contract." : "Hydrate the full hosted context bundle with `decantr registry compile-packs decantr.essence.json --write-context` so critique consumers can anchor findings to the compiled review contract."
       })
     );
@@ -6826,74 +7590,74 @@ function countKeyboardShortcutSignals(code) {
   return matches.length;
 }
 function getScriptKind(filePath) {
-  switch (extname4(filePath).toLowerCase()) {
+  switch (extname6(filePath).toLowerCase()) {
     case ".tsx":
-      return ts3.ScriptKind.TSX;
+      return ts6.ScriptKind.TSX;
     case ".jsx":
-      return ts3.ScriptKind.JSX;
+      return ts6.ScriptKind.JSX;
     case ".ts":
-      return ts3.ScriptKind.TS;
+      return ts6.ScriptKind.TS;
     case ".js":
-      return ts3.ScriptKind.JS;
+      return ts6.ScriptKind.JS;
     default:
-      return ts3.ScriptKind.TSX;
+      return ts6.ScriptKind.TSX;
   }
 }
 function isPropertyNamed(node, ...names) {
   if (!node) return false;
-  if (ts3.isIdentifier(node)) {
+  if (ts6.isIdentifier(node)) {
     return names.includes(node.text);
   }
-  if (ts3.isPrivateIdentifier(node)) {
+  if (ts6.isPrivateIdentifier(node)) {
     return names.includes(node.text);
   }
-  if (ts3.isStringLiteral(node)) {
+  if (ts6.isStringLiteral(node)) {
     return names.includes(node.text);
   }
   return false;
 }
 function getJsxAttribute(attributes, ...names) {
   return attributes.properties.find(
-    (property) => ts3.isJsxAttribute(property) && isPropertyNamed(property.name, ...names)
+    (property) => ts6.isJsxAttribute(property) && isPropertyNamed(property.name, ...names)
   );
 }
 function getJsxTagName(node) {
-  if (ts3.isIdentifier(node.tagName)) {
+  if (ts6.isIdentifier(node.tagName)) {
     return node.tagName.text;
   }
-  if (ts3.isPropertyAccessExpression(node.tagName)) {
+  if (ts6.isPropertyAccessExpression(node.tagName)) {
     return node.tagName.name.text;
   }
   return null;
 }
 function getJsxAttributeLiteralValue(attribute) {
   if (!attribute?.initializer) return null;
-  if (ts3.isStringLiteral(attribute.initializer)) {
+  if (ts6.isStringLiteral(attribute.initializer)) {
     return attribute.initializer.text;
   }
-  if (ts3.isJsxExpression(attribute.initializer)) {
+  if (ts6.isJsxExpression(attribute.initializer)) {
     const expression = attribute.initializer.expression;
     if (!expression) return "";
-    if (ts3.isStringLiteral(expression) || ts3.isNoSubstitutionTemplateLiteral(expression)) {
+    if (ts6.isStringLiteral(expression) || ts6.isNoSubstitutionTemplateLiteral(expression)) {
       return expression.text;
     }
   }
   return null;
 }
 function getJsxTextContent(node) {
-  if (ts3.isJsxText(node)) {
+  if (ts6.isJsxText(node)) {
     return node.getText();
   }
-  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
-  if (ts3.isJsxExpression(node)) {
+  if (ts6.isJsxExpression(node)) {
     return node.expression ? getJsxTextContent(node.expression) : "";
   }
-  if (ts3.isJsxSelfClosingElement(node) || ts3.isJsxOpeningElement(node)) {
+  if (ts6.isJsxSelfClosingElement(node) || ts6.isJsxOpeningElement(node)) {
     return "";
   }
-  if (ts3.isJsxElement(node) || ts3.isJsxFragment(node)) {
+  if (ts6.isJsxElement(node) || ts6.isJsxFragment(node)) {
     return node.children.map((child) => getJsxTextContent(child)).join("");
   }
   let text = "";
@@ -6913,7 +7677,7 @@ function isNonSemanticInteractiveTag(tagName) {
 function collectLabelForIds(root) {
   const ids = /* @__PURE__ */ new Set();
   const walk = (node) => {
-    if (ts3.isJsxSelfClosingElement(node) || ts3.isJsxOpeningElement(node)) {
+    if (ts6.isJsxSelfClosingElement(node) || ts6.isJsxOpeningElement(node)) {
       const tagName = getJsxTagName(node);
       if (tagName === "label") {
         const htmlForValue = getJsxAttributeLiteralValue(
@@ -6924,7 +7688,7 @@ function collectLabelForIds(root) {
         }
       }
     }
-    ts3.forEachChild(node, walk);
+    ts6.forEachChild(node, walk);
   };
   walk(root);
   return ids;
@@ -6932,7 +7696,7 @@ function collectLabelForIds(root) {
 function isWrappedInJsxLabel(node) {
   let current = node.parent;
   while (current) {
-    if (ts3.isJsxElement(current) && getJsxTagName(current.openingElement) === "label") {
+    if (ts6.isJsxElement(current) && getJsxTagName(current.openingElement) === "label") {
       return true;
     }
     current = current.parent;
@@ -6942,7 +7706,7 @@ function isWrappedInJsxLabel(node) {
 function hasAncestorJsxTag(node, tagName) {
   let current = node.parent;
   while (current) {
-    if (ts3.isJsxElement(current) && getJsxTagName(current.openingElement) === tagName) {
+    if (ts6.isJsxElement(current) && getJsxTagName(current.openingElement) === tagName) {
       return true;
     }
     current = current.parent;
@@ -7020,9 +7784,9 @@ function hasNavigationLabel(attributes) {
 }
 function getJsxAttributeOwner(attribute) {
   const attributes = attribute.parent;
-  if (!attributes || !ts3.isJsxAttributes(attributes)) return null;
+  if (!attributes || !ts6.isJsxAttributes(attributes)) return null;
   const owner = attributes.parent;
-  if (ts3.isJsxOpeningElement(owner) || ts3.isJsxSelfClosingElement(owner)) {
+  if (ts6.isJsxOpeningElement(owner) || ts6.isJsxSelfClosingElement(owner)) {
     return owner;
   }
   return null;
@@ -7109,14 +7873,14 @@ function jsxTreeContainsAuthInput(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts3.isJsxSelfClosingElement(current)) {
+    if (ts6.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName === "input" && isAuthLikeInputAttributes(current.attributes)) {
         found = true;
       }
       return;
     }
-    if (ts3.isJsxElement(current)) {
+    if (ts6.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName === "input" && isAuthLikeInputAttributes(current.openingElement.attributes)) {
         found = true;
@@ -7128,7 +7892,7 @@ function jsxTreeContainsAuthInput(node) {
       }
       return;
     }
-    if (ts3.isJsxFragment(current)) {
+    if (ts6.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -7152,7 +7916,7 @@ function jsxTreeHasSubmitControl(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts3.isJsxSelfClosingElement(current)) {
+    if (ts6.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName === "button") {
         const typeValue = getJsxAttributeLiteralValue(getJsxAttribute(current.attributes, "type"))?.trim().toLowerCase();
@@ -7168,7 +7932,7 @@ function jsxTreeHasSubmitControl(node) {
       }
       return;
     }
-    if (ts3.isJsxElement(current)) {
+    if (ts6.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName === "button") {
         const typeValue = getJsxAttributeLiteralValue(
@@ -7192,7 +7956,7 @@ function jsxTreeHasSubmitControl(node) {
       }
       return;
     }
-    if (ts3.isJsxFragment(current)) {
+    if (ts6.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -7209,14 +7973,14 @@ function jsxTreeHasTag(node, tagNames) {
   const wanted = new Set(tagNames);
   const visit = (current) => {
     if (found) return;
-    if (ts3.isJsxSelfClosingElement(current)) {
+    if (ts6.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName && wanted.has(tagName)) {
         found = true;
       }
       return;
     }
-    if (ts3.isJsxElement(current)) {
+    if (ts6.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName && wanted.has(tagName)) {
         found = true;
@@ -7228,7 +7992,7 @@ function jsxTreeHasTag(node, tagNames) {
       }
       return;
     }
-    if (ts3.isJsxFragment(current)) {
+    if (ts6.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -7245,22 +8009,22 @@ function hasAuthFormWithoutSubmitControl(node) {
 }
 function getExpressionLiteralValue(expression) {
   if (!expression) return null;
-  if (ts3.isStringLiteral(expression) || ts3.isNoSubstitutionTemplateLiteral(expression)) {
+  if (ts6.isStringLiteral(expression) || ts6.isNoSubstitutionTemplateLiteral(expression)) {
     return expression.text;
   }
-  if (ts3.isParenthesizedExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression)) {
     return getExpressionLiteralValue(expression.expression);
   }
-  if (ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression)) {
+  if (ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression)) {
     return getExpressionLiteralValue(expression.expression);
   }
   return null;
 }
 function getObjectLiteralStringPropertyValue(expression, ...propertyNames) {
-  if (!expression || !ts3.isObjectLiteralExpression(expression)) return null;
+  if (!expression || !ts6.isObjectLiteralExpression(expression)) return null;
   for (const property of expression.properties) {
-    if (!ts3.isPropertyAssignment(property)) continue;
-    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!ts6.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts6.isIdentifier(property.name) ? property.name.text : ts6.isStringLiteral(property.name) ? property.name.text : null;
     if (!propertyName2 || !propertyNames.includes(propertyName2)) continue;
     const value = getExpressionLiteralValue(property.initializer);
     if (value) return value;
@@ -7268,24 +8032,24 @@ function getObjectLiteralStringPropertyValue(expression, ...propertyNames) {
   return null;
 }
 function getObjectLiteralBooleanPropertyValue(expression, ...propertyNames) {
-  if (!expression || !ts3.isObjectLiteralExpression(expression)) return null;
+  if (!expression || !ts6.isObjectLiteralExpression(expression)) return null;
   for (const property of expression.properties) {
-    if (!ts3.isPropertyAssignment(property)) continue;
-    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!ts6.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts6.isIdentifier(property.name) ? property.name.text : ts6.isStringLiteral(property.name) ? property.name.text : null;
     if (!propertyName2 || !propertyNames.includes(propertyName2)) continue;
-    if (property.initializer.kind === ts3.SyntaxKind.TrueKeyword) return true;
-    if (property.initializer.kind === ts3.SyntaxKind.FalseKeyword) return false;
+    if (property.initializer.kind === ts6.SyntaxKind.TrueKeyword) return true;
+    if (property.initializer.kind === ts6.SyntaxKind.FalseKeyword) return false;
   }
   return null;
 }
 function collectNamedFunctionLikeDeclarations(root) {
   const declarations = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts3.isFunctionDeclaration(node) && node.name && ts3.isIdentifier(node.name)) {
+    if (ts6.isFunctionDeclaration(node) && node.name && ts6.isIdentifier(node.name)) {
       declarations.set(node.name.text, node);
     }
-    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
-      if (ts3.isArrowFunction(node.initializer) || ts3.isFunctionExpression(node.initializer)) {
+    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name) && node.initializer) {
+      if (ts6.isArrowFunction(node.initializer) || ts6.isFunctionExpression(node.initializer)) {
         declarations.set(node.name.text, node.initializer);
       }
     }
@@ -7305,12 +8069,12 @@ function getCachedNamedFunctionLikeDeclarations(sourceFile) {
 function collectNamedExpressionInitializers(root) {
   const initializers = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
+    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name) && node.initializer) {
       initializers.set(node.name.text, node.initializer);
     }
-    if (ts3.isVariableDeclaration(node) && ts3.isArrayBindingPattern(node.name) && node.initializer) {
+    if (ts6.isVariableDeclaration(node) && ts6.isArrayBindingPattern(node.name) && node.initializer) {
       const firstElement = node.name.elements[0];
-      if (firstElement && !ts3.isOmittedExpression(firstElement) && ts3.isBindingElement(firstElement) && ts3.isIdentifier(firstElement.name)) {
+      if (firstElement && !ts6.isOmittedExpression(firstElement) && ts6.isBindingElement(firstElement) && ts6.isIdentifier(firstElement.name)) {
         initializers.set(firstElement.name.text, node.initializer);
       }
     }
@@ -7321,7 +8085,7 @@ function collectNamedExpressionInitializers(root) {
 }
 function getPropertyNameText(name) {
   if (!name) return null;
-  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+  if (ts6.isIdentifier(name) || ts6.isStringLiteral(name) || ts6.isNumericLiteral(name)) {
     return name.text;
   }
   return null;
@@ -7334,20 +8098,20 @@ function collectNamedPropertyAliases(root) {
       const propertyName2 = getPropertyNameText(element.propertyName) ?? getPropertyNameText(element.name);
       if (!propertyName2) continue;
       const nextPath = [...propertyPath, propertyName2];
-      if (ts3.isIdentifier(element.name)) {
+      if (ts6.isIdentifier(element.name)) {
         aliases.set(element.name.text, { initializer, propertyName: propertyName2, propertyPath: nextPath });
         continue;
       }
-      if (ts3.isObjectBindingPattern(element.name)) {
+      if (ts6.isObjectBindingPattern(element.name)) {
         collectFromBindingPattern(element.name, initializer, nextPath);
       }
     }
   };
   const visit = (node) => {
-    if (ts3.isVariableDeclaration(node) && ts3.isObjectBindingPattern(node.name) && node.initializer) {
+    if (ts6.isVariableDeclaration(node) && ts6.isObjectBindingPattern(node.name) && node.initializer) {
       collectFromBindingPattern(node.name, node.initializer, []);
     }
-    if (ts3.isParameter(node) && ts3.isObjectBindingPattern(node.name)) {
+    if (ts6.isParameter(node) && ts6.isObjectBindingPattern(node.name)) {
       collectFromBindingPattern(node.name, void 0, []);
     }
     node.forEachChild(visit);
@@ -7357,28 +8121,28 @@ function collectNamedPropertyAliases(root) {
 }
 function resolveFunctionLikeHandler(expression, namedFunctions) {
   if (!expression) return null;
-  if (ts3.isArrowFunction(expression) || ts3.isFunctionExpression(expression)) {
+  if (ts6.isArrowFunction(expression) || ts6.isFunctionExpression(expression)) {
     return expression;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     return namedFunctions.get(expression.text) ?? null;
   }
   return null;
 }
 function getFunctionLikeReturnExpressions(node) {
-  if (ts3.isArrowFunction(node) && !ts3.isBlock(node.body)) {
+  if (ts6.isArrowFunction(node) && !ts6.isBlock(node.body)) {
     return [node.body];
   }
   const body = node.body;
-  if (!body || !ts3.isBlock(body)) {
+  if (!body || !ts6.isBlock(body)) {
     return [];
   }
   const expressions = [];
   const visit = (current) => {
-    if (current !== body && (ts3.isFunctionDeclaration(current) || ts3.isFunctionExpression(current) || ts3.isArrowFunction(current) || ts3.isMethodDeclaration(current) || ts3.isGetAccessorDeclaration(current) || ts3.isSetAccessorDeclaration(current) || ts3.isConstructorDeclaration(current))) {
+    if (current !== body && (ts6.isFunctionDeclaration(current) || ts6.isFunctionExpression(current) || ts6.isArrowFunction(current) || ts6.isMethodDeclaration(current) || ts6.isGetAccessorDeclaration(current) || ts6.isSetAccessorDeclaration(current) || ts6.isConstructorDeclaration(current))) {
       return;
     }
-    if (ts3.isReturnStatement(current) && current.expression) {
+    if (ts6.isReturnStatement(current) && current.expression) {
       expressions.push(current.expression);
       return;
     }
@@ -7394,7 +8158,7 @@ function bindFunctionLikeArguments(functionLike, args, namedExpressions) {
   const boundExpressions = new Map(namedExpressions);
   functionLike.parameters.forEach((parameter, index) => {
     const argument = args[index];
-    if (!argument || !ts3.isIdentifier(parameter.name)) return;
+    if (!argument || !ts6.isIdentifier(parameter.name)) return;
     boundExpressions.set(parameter.name.text, argument);
   });
   return boundExpressions;
@@ -7408,10 +8172,10 @@ function getMemberAccessPropertyName(expression) {
 }
 function getObjectLiteralPropertyExpression(objectLiteral, propertyName2, namedExpressions) {
   for (const property of objectLiteral.properties) {
-    if (ts3.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
+    if (ts6.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
       return property.initializer;
     }
-    if (ts3.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
+    if (ts6.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
       return namedExpressions.get(property.name.text) ?? null;
     }
   }
@@ -7477,7 +8241,7 @@ function resolveReturnedObjectLiteralExpression(functionLike, args, sourceFile,
 function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers, seenFunctions = /* @__PURE__ */ new Set(), depth = 0) {
   if (!expression) return null;
   if (depth > MAX_OPEN_REDIRECT_RESOLUTION_DEPTH) return null;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return resolveObjectLiteralExpression(
       expression.expression,
       sourceFile,
@@ -7488,10 +8252,10 @@ function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions
       depth + 1
     );
   }
-  if (ts3.isObjectLiteralExpression(expression)) {
+  if (ts6.isObjectLiteralExpression(expression)) {
     return { objectLiteral: expression, namedExpressions };
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return null;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -7564,13 +8328,13 @@ function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions
 }
 function findFunctionLikeOnObjectLiteral(objectLiteral, propertyName2, namedFunctions) {
   for (const property of objectLiteral.properties) {
-    if (ts3.isMethodDeclaration(property) && getPropertyNameText(property.name) === propertyName2) {
+    if (ts6.isMethodDeclaration(property) && getPropertyNameText(property.name) === propertyName2) {
       return property;
     }
-    if (ts3.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
+    if (ts6.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
       return resolveFunctionLikeHandler(property.initializer, namedFunctions);
     }
-    if (ts3.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
+    if (ts6.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
       return namedFunctions.get(property.name.text) ?? null;
     }
   }
@@ -7605,7 +8369,7 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
   if (directFunctionLike) {
     return { functionLike: directFunctionLike, namedExpressions };
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return resolveTrackedOpenRedirectFunctionLike(
       expression.expression,
       sourceFile,
@@ -7638,7 +8402,7 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
       depth + 1
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return null;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -7701,16 +8465,16 @@ function functionLikeReferencesOrigin(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts3.isPropertyAccessExpression(current) && isPropertyNamed(current.name, "origin")) {
+    if (ts6.isPropertyAccessExpression(current) && isPropertyNamed(current.name, "origin")) {
       found = true;
       return;
     }
-    if (ts3.isIdentifier(current) && current.text === "origin") {
+    if (ts6.isIdentifier(current) && current.text === "origin") {
       found = true;
       return;
     }
-    if (ts3.isBindingElement(current)) {
-      if (ts3.isIdentifier(current.name) && current.name.text === "origin") {
+    if (ts6.isBindingElement(current)) {
+      if (ts6.isIdentifier(current.name) && current.name.text === "origin") {
         found = true;
         return;
       }
@@ -7725,13 +8489,13 @@ function functionLikeReferencesOrigin(node) {
   return found;
 }
 function isAddEventListenerCall(node) {
-  return ts3.isIdentifier(node.expression) && node.expression.text === "addEventListener" || ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "addEventListener");
+  return ts6.isIdentifier(node.expression) && node.expression.text === "addEventListener" || ts6.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "addEventListener");
 }
 function isCookieMutationSetCall(node) {
-  if (!ts3.isPropertyAccessExpression(node.expression) || !isPropertyNamed(node.expression.name, "set")) {
+  if (!ts6.isPropertyAccessExpression(node.expression) || !isPropertyNamed(node.expression.name, "set")) {
     return false;
   }
-  return ts3.isIdentifier(node.expression.expression) && ["Cookies", "cookieStore", "cookies"].includes(node.expression.expression.text) || ts3.isPropertyAccessExpression(node.expression.expression) && isPropertyNamed(node.expression.expression.name, "cookies", "cookieStore");
+  return ts6.isIdentifier(node.expression.expression) && ["Cookies", "cookieStore", "cookies"].includes(node.expression.expression.text) || ts6.isPropertyAccessExpression(node.expression.expression) && isPropertyNamed(node.expression.expression.name, "cookies", "cookieStore");
 }
 function expressionLooksLikeAuthCookieName(node, sourceFile) {
   if (!node) return false;
@@ -7739,17 +8503,17 @@ function expressionLooksLikeAuthCookieName(node, sourceFile) {
   return hasAuthCredentialText(node, sourceFile);
 }
 function objectLiteralLooksLikeAuthCookieConfig(expression, sourceFile) {
-  if (!expression || !ts3.isObjectLiteralExpression(expression)) return false;
+  if (!expression || !ts6.isObjectLiteralExpression(expression)) return false;
   for (const property of expression.properties) {
-    if (!ts3.isPropertyAssignment(property)) continue;
-    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!ts6.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts6.isIdentifier(property.name) ? property.name.text : ts6.isStringLiteral(property.name) ? property.name.text : null;
     if (!propertyName2 || !["name", "key", "cookie"].includes(propertyName2)) continue;
     return expressionLooksLikeAuthCookieName(property.initializer, sourceFile);
   }
   return false;
 }
 function hasExplicitAuthCookieHardening(expression) {
-  if (!expression || !ts3.isObjectLiteralExpression(expression)) return false;
+  if (!expression || !ts6.isObjectLiteralExpression(expression)) return false;
   const httpOnly = getObjectLiteralBooleanPropertyValue(expression, "httpOnly", "http_only");
   const secure = getObjectLiteralBooleanPropertyValue(expression, "secure");
   const sameSite = getObjectLiteralStringPropertyValue(expression, "sameSite", "same_site");
@@ -7769,8 +8533,8 @@ function collectCookieHeaderStrings(expression) {
   if (!expression) return [];
   const literal = getExpressionLiteralValue(expression);
   if (literal !== null) return [literal];
-  if (ts3.isArrayLiteralExpression(expression)) {
-    return expression.elements.map((element) => ts3.isExpression(element) ? getExpressionLiteralValue(element) : null).filter((value) => value !== null);
+  if (ts6.isArrayLiteralExpression(expression)) {
+    return expression.elements.map((element) => ts6.isExpression(element) ? getExpressionLiteralValue(element) : null).filter((value) => value !== null);
   }
   return [];
 }
@@ -7778,16 +8542,16 @@ function isInsecureTransportUrl(value) {
   return typeof value === "string" && /^(?:http|ws):\/\//i.test(value.trim());
 }
 function isPropertyLikeAccessExpression(node) {
-  return Boolean(node && (ts3.isPropertyAccessExpression(node) || ts3.isPropertyAccessChain(node)));
+  return Boolean(node && (ts6.isPropertyAccessExpression(node) || ts6.isPropertyAccessChain(node)));
 }
 function isElementLikeAccessExpression(node) {
-  return Boolean(node && (ts3.isElementAccessExpression(node) || ts3.isElementAccessChain(node)));
+  return Boolean(node && (ts6.isElementAccessExpression(node) || ts6.isElementAccessChain(node)));
 }
 function isMemberAccessExpression(node) {
   return isPropertyLikeAccessExpression(node) || isElementLikeAccessExpression(node);
 }
 function isCallLikeExpression(node) {
-  return Boolean(node && (ts3.isCallExpression(node) || ts3.isCallChain(node)));
+  return Boolean(node && (ts6.isCallExpression(node) || ts6.isCallChain(node)));
 }
 function isMemberAccessNamed(node, ...names) {
   if (!node) return false;
@@ -7800,19 +8564,19 @@ function isMemberAccessNamed(node, ...names) {
   return false;
 }
 function isLocationObjectExpression(expression) {
-  return ts3.isIdentifier(expression) && expression.text === "location" || (ts3.isPropertyAccessExpression(expression) || ts3.isElementAccessExpression(expression)) && ts3.isIdentifier(expression.expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(
+  return ts6.isIdentifier(expression) && expression.text === "location" || (ts6.isPropertyAccessExpression(expression) || ts6.isElementAccessExpression(expression)) && ts6.isIdentifier(expression.expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(
     expression.expression.text
   ) && isMemberAccessNamed(expression, "location");
 }
 function isLocationAssignmentTarget(expression) {
-  return isLocationObjectExpression(expression) || (ts3.isPropertyAccessExpression(expression) || ts3.isElementAccessExpression(expression)) && isLocationObjectExpression(expression.expression) && isMemberAccessNamed(expression, "href");
+  return isLocationObjectExpression(expression) || (ts6.isPropertyAccessExpression(expression) || ts6.isElementAccessExpression(expression)) && isLocationObjectExpression(expression.expression) && isMemberAccessNamed(expression, "href");
 }
 function isFetchLikeCall(node) {
-  return ts3.isIdentifier(node.expression) && node.expression.text === "fetch" || ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "fetch");
+  return ts6.isIdentifier(node.expression) && node.expression.text === "fetch" || ts6.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "fetch");
 }
 function isAxiosLikeCall(node) {
-  if (!ts3.isPropertyAccessExpression(node.expression)) return false;
-  return ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "axios" && isPropertyNamed(
+  if (!ts6.isPropertyAccessExpression(node.expression)) return false;
+  return ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "axios" && isPropertyNamed(
     node.expression.name,
     "get",
     "post",
@@ -7825,10 +8589,10 @@ function isAxiosLikeCall(node) {
   );
 }
 function isAxiosConfigCall(node) {
-  return ts3.isIdentifier(node.expression) && node.expression.text === "axios";
+  return ts6.isIdentifier(node.expression) && node.expression.text === "axios";
 }
 function isRealtimeTransportConstructor(node) {
-  return ts3.isIdentifier(node.expression) && (node.expression.text === "WebSocket" || node.expression.text === "EventSource");
+  return ts6.isIdentifier(node.expression) && (node.expression.text === "WebSocket" || node.expression.text === "EventSource");
 }
 function hasPlaceholderNavigationTarget(attributes) {
   const targetValue = getJsxAttributeLiteralValue(getJsxAttribute(attributes, "href", "to"));
@@ -7895,40 +8659,40 @@ function getSkipNavTargetId(attributes, tagName) {
 }
 function isAuthStorageKeyLiteral(node) {
   if (!node) return false;
-  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) {
     if (node.text === "decantr_authenticated") return false;
     return /(?:token|auth|jwt|session|access_token|refresh_token)/i.test(node.text);
   }
   return false;
 }
 function isBrowserStorageObject(node) {
-  return ts3.isIdentifier(node) && (node.text === "localStorage" || node.text === "sessionStorage");
+  return ts6.isIdentifier(node) && (node.text === "localStorage" || node.text === "sessionStorage");
 }
 function isDocumentObject(node) {
-  return ts3.isIdentifier(node) && node.text === "document";
+  return ts6.isIdentifier(node) && node.text === "document";
 }
 function isCookiePropertyAccess(node) {
-  return ts3.isPropertyAccessExpression(node) && isDocumentObject(node.expression) && isPropertyNamed(node.name, "cookie");
+  return ts6.isPropertyAccessExpression(node) && isDocumentObject(node.expression) && isPropertyNamed(node.name, "cookie");
 }
 function hasAuthCredentialText(node, sourceFile) {
   return /(?:token|auth|jwt|session|access_token|refresh_token)/i.test(node.getText(sourceFile));
 }
 function isAuthorizationHeaderName(node) {
   if (!node) return false;
-  if (ts3.isIdentifier(node)) {
+  if (ts6.isIdentifier(node)) {
     return /^authorization$/i.test(node.text);
   }
-  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) {
     return /^authorization$/i.test(node.text);
   }
-  if (ts3.isComputedPropertyName(node)) {
+  if (ts6.isComputedPropertyName(node)) {
     return isAuthorizationHeaderName(node.expression);
   }
   return false;
 }
 function isAuthorizationHeaderAccess(node) {
   if (!node) return false;
-  return ts3.isPropertyAccessExpression(node) && isAuthorizationHeaderName(node.name) || ts3.isElementAccessExpression(node) && isAuthorizationHeaderName(node.argumentExpression);
+  return ts6.isPropertyAccessExpression(node) && isAuthorizationHeaderName(node.name) || ts6.isElementAccessExpression(node) && isAuthorizationHeaderName(node.argumentExpression);
 }
 function isHeaderClearValue(node) {
   if (!node) return false;
@@ -7936,7 +8700,7 @@ function isHeaderClearValue(node) {
   if (literal !== null) {
     return literal.trim().length === 0;
   }
-  return node.kind === ts3.SyntaxKind.NullKeyword || node.kind === ts3.SyntaxKind.UndefinedKeyword || ts3.isIdentifier(node) && node.text === "undefined";
+  return node.kind === ts6.SyntaxKind.NullKeyword || node.kind === ts6.SyntaxKind.UndefinedKeyword || ts6.isIdentifier(node) && node.text === "undefined";
 }
 function countAuthGuardSignals(code) {
   const patterns = [
@@ -8685,7 +9449,7 @@ function propertyPathLooksLikeOpenRedirectQueryContainerBase(propertyPath) {
 }
 function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFile, namedExpressions = /* @__PURE__ */ new Map(), namedPropertyAliases = /* @__PURE__ */ new Map(), seenIdentifiers = /* @__PURE__ */ new Set(), seenFunctions = /* @__PURE__ */ new Set()) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.expression,
       sourceFile,
@@ -8712,7 +9476,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       )
     );
   }
-  if (ts3.isBinaryExpression(expression) && (expression.operatorToken.kind === ts3.SyntaxKind.QuestionQuestionToken || expression.operatorToken.kind === ts3.SyntaxKind.BarBarToken)) {
+  if (ts6.isBinaryExpression(expression) && (expression.operatorToken.kind === ts6.SyntaxKind.QuestionQuestionToken || expression.operatorToken.kind === ts6.SyntaxKind.BarBarToken)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.left,
       sourceFile,
@@ -8729,7 +9493,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts3.isConditionalExpression(expression)) {
+  if (ts6.isConditionalExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.whenTrue,
       sourceFile,
@@ -8746,7 +9510,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts3.isTemplateExpression(expression)) {
+  if (ts6.isTemplateExpression(expression)) {
     return expression.templateSpans.some(
       (span) => expressionLooksLikeOpenRedirectQueryGetterFunction(
         span.expression,
@@ -8758,7 +9522,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       )
     );
   }
-  if (ts3.isTaggedTemplateExpression(expression)) {
+  if (ts6.isTaggedTemplateExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.template,
       sourceFile,
@@ -8768,7 +9532,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalBooleanHelper(
+  if (ts6.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalBooleanHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -8784,7 +9548,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalNumberHelper(
+  if (ts6.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalNumberHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -8800,7 +9564,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalObjectHelper(
+  if (ts6.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalObjectHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -8816,7 +9580,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalStringHelper(
+  if (ts6.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalStringHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -8848,7 +9612,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalSymbolHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalSymbolHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -8912,7 +9676,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBigIntHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBigIntHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -8976,7 +9740,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBooleanHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBooleanHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9040,7 +9804,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalNumberHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalNumberHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9104,7 +9868,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalObjectHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalObjectHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9152,7 +9916,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && ts3.isIdentifier(expression.expression) && [
+  if (isCallLikeExpression(expression) && ts6.isIdentifier(expression.expression) && [
     "String",
     "atob",
     "btoa",
@@ -9188,7 +9952,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonStringifyHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonStringifyHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9252,7 +10016,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonParseHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonParseHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9316,7 +10080,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeStructuredCloneHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeStructuredCloneHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9380,7 +10144,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalStringHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalStringHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9460,7 +10224,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalUriCodecHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalUriCodecHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9508,7 +10272,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBase64Helper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBase64Helper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9556,7 +10320,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) || isMemberAccessExpression(expression.expression)) && expression.arguments.length > 0 && expressionLooksLikeBufferFromHelper(
+  if (isCallLikeExpression(expression) && (ts6.isIdentifier(expression.expression) || isMemberAccessExpression(expression.expression)) && expression.arguments.length > 0 && expressionLooksLikeBufferFromHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -9608,7 +10372,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBufferFromHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBufferFromHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9656,7 +10420,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "from") && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Buffer" && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "from") && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Buffer" && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9835,7 +10599,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isElementLikeAccessExpression(expression) && ts3.isNumericLiteral(expression.argumentExpression) && expression.argumentExpression.text === "1" && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "value") && isCallLikeExpression(expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression) && isMemberAccessNamed(expression.expression.expression.expression, "next") && isCallLikeExpression(expression.expression.expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression.expression.expression) && isMemberAccessNamed(
+  if (isElementLikeAccessExpression(expression) && ts6.isNumericLiteral(expression.argumentExpression) && expression.argumentExpression.text === "1" && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "value") && isCallLikeExpression(expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression) && isMemberAccessNamed(expression.expression.expression.expression, "next") && isCallLikeExpression(expression.expression.expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression.expression.expression) && isMemberAccessNamed(
     expression.expression.expression.expression.expression.expression,
     "entries"
   ) && expressionLooksLikeOpenRedirectQueryGetterFunction(
@@ -9868,7 +10632,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9878,8 +10642,8 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts3.isArrayLiteralExpression(expression) && expression.elements.some(
-    (element) => ts3.isSpreadElement(element) && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (ts6.isArrayLiteralExpression(expression) && expression.elements.some(
+    (element) => ts6.isSpreadElement(element) && expressionLooksLikeOpenRedirectQueryGetterFunction(
       element.expression,
       sourceFile,
       namedExpressions,
@@ -9930,7 +10694,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9964,7 +10728,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
   if (OPEN_REDIRECT_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.expression,
       sourceFile,
@@ -9974,7 +10738,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts3.isBinaryExpression(expression)) {
+  if (ts6.isBinaryExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.left,
       sourceFile,
@@ -9991,7 +10755,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts3.isConditionalExpression(expression)) {
+  if (ts6.isConditionalExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.condition,
       sourceFile,
@@ -10015,7 +10779,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts3.isTemplateExpression(expression)) {
+  if (ts6.isTemplateExpression(expression)) {
     return expression.templateSpans.some(
       (span) => expressionContainsOpenRedirectSource(
         span.expression,
@@ -10027,7 +10791,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       )
     );
   }
-  if (ts3.isTaggedTemplateExpression(expression)) {
+  if (ts6.isTaggedTemplateExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.template,
       sourceFile,
@@ -10037,7 +10801,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts3.isNewExpression(expression)) {
+  if (ts6.isNewExpression(expression)) {
     return (expression.arguments ?? []).some(
       (argument) => expressionContainsOpenRedirectSource(
         argument,
@@ -10049,9 +10813,9 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       )
     );
   }
-  if (ts3.isArrayLiteralExpression(expression)) {
+  if (ts6.isArrayLiteralExpression(expression)) {
     return expression.elements.some((element) => {
-      if (ts3.isSpreadElement(element)) {
+      if (ts6.isSpreadElement(element)) {
         return expressionContainsOpenRedirectSource(
           element.expression,
           sourceFile,
@@ -10061,7 +10825,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      return ts3.isExpression(element) && expressionContainsOpenRedirectSource(
+      return ts6.isExpression(element) && expressionContainsOpenRedirectSource(
         element,
         sourceFile,
         namedExpressions,
@@ -10071,9 +10835,9 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       );
     });
   }
-  if (ts3.isObjectLiteralExpression(expression)) {
+  if (ts6.isObjectLiteralExpression(expression)) {
     return expression.properties.some((property) => {
-      if (ts3.isPropertyAssignment(property)) {
+      if (ts6.isPropertyAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.initializer,
           sourceFile,
@@ -10083,7 +10847,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      if (ts3.isShorthandPropertyAssignment(property)) {
+      if (ts6.isShorthandPropertyAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.name,
           sourceFile,
@@ -10093,7 +10857,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      if (ts3.isSpreadAssignment(property)) {
+      if (ts6.isSpreadAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.expression,
           sourceFile,
@@ -10148,7 +10912,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       }
     }
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && isOpenRedirectQueryKeyExpression(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && isOpenRedirectQueryKeyExpression(
     getAliasedApplyArgumentExpression(expression.arguments[2], 0, namedExpressions, /* @__PURE__ */ new Set()),
     namedExpressions,
     seenIdentifiers
@@ -10264,7 +11028,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) {
       return false;
     }
@@ -10302,14 +11066,14 @@ function isOpenRedirectQueryKeyExpression(expression, namedExpressions = /* @__P
     return true;
   }
   if (!expression) return false;
-  if (ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression) || ts3.isParenthesizedExpression(expression)) {
+  if (ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression) || ts6.isParenthesizedExpression(expression)) {
     return isOpenRedirectQueryKeyExpression(
       expression.expression,
       namedExpressions,
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -10325,7 +11089,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
   if (OPEN_REDIRECT_QUERY_CARRIER_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryCarrier(
       expression.expression,
       sourceFile,
@@ -10334,7 +11098,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Object" && isPropertyNamed(expression.expression.name, "fromEntries") && expression.arguments.length > 0) {
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Object" && isPropertyNamed(expression.expression.name, "fromEntries") && expression.arguments.length > 0) {
     const entriesExpression = expression.arguments[0];
     if (expressionLooksLikeOpenRedirectSearchParamsCarrier(
       entriesExpression,
@@ -10364,7 +11128,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10397,7 +11161,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
 }
 function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectEntriesCarrier(
       expression.expression,
       sourceFile,
@@ -10406,7 +11170,7 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && (expressionLooksLikeOpenRedirectEntriesCarrier(
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts6.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && (expressionLooksLikeOpenRedirectEntriesCarrier(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -10421,8 +11185,8 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
   ))) {
     return true;
   }
-  if (ts3.isArrayLiteralExpression(expression) && expression.elements.some(
-    (element) => ts3.isSpreadElement(element) && (expressionLooksLikeOpenRedirectEntriesCarrier(
+  if (ts6.isArrayLiteralExpression(expression) && expression.elements.some(
+    (element) => ts6.isSpreadElement(element) && (expressionLooksLikeOpenRedirectEntriesCarrier(
       element.expression,
       sourceFile,
       namedExpressions,
@@ -10447,7 +11211,7 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -10469,7 +11233,7 @@ function expressionLooksLikeOpenRedirectQueryContainerBase(expression, sourceFil
   if (OPEN_REDIRECT_QUERY_CONTAINER_BASE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryContainerBase(
       expression.expression,
       sourceFile,
@@ -10478,10 +11242,10 @@ function expressionLooksLikeOpenRedirectQueryContainerBase(expression, sourceFil
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useRouter" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useRouter"))) {
+  if (isCallLikeExpression(expression) && (ts6.isIdentifier(expression.expression) && expression.expression.text === "useRouter" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useRouter"))) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10519,7 +11283,7 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
   if (LOCATION_QUERY_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationQuerySource(
       expression.expression,
       sourceFile,
@@ -10552,7 +11316,7 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
   ))) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10588,10 +11352,10 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
 }
 function expressionLooksLikeWindowObjectSource(expression, sourceFile, namedExpressions, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(expression.text)) {
+  if (ts6.isIdentifier(expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(expression.text)) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeWindowObjectSource(
       expression.expression,
       sourceFile,
@@ -10599,7 +11363,7 @@ function expressionLooksLikeWindowObjectSource(expression, sourceFile, namedExpr
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -10620,7 +11384,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
   if (isLocationObjectExpression(expression)) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationObjectSource(
       expression.expression,
       sourceFile,
@@ -10629,7 +11393,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useLocation" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useLocation"))) {
+  if (isCallLikeExpression(expression) && (ts6.isIdentifier(expression.expression) && expression.expression.text === "useLocation" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useLocation"))) {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "location") && expressionLooksLikeWindowObjectSource(
@@ -10640,7 +11404,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10669,10 +11433,10 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
 }
 function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "history") {
+  if (ts6.isIdentifier(expression) && expression.text === "history") {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeHistoryObjectSource(
       expression.expression,
       sourceFile,
@@ -10689,7 +11453,7 @@ function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExp
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10718,10 +11482,10 @@ function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExp
 }
 function expressionLooksLikeBufferObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "Buffer") {
+  if (ts6.isIdentifier(expression) && expression.text === "Buffer") {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBufferObjectSource(
       expression.expression,
       sourceFile,
@@ -10738,7 +11502,7 @@ function expressionLooksLikeBufferObjectSource(expression, sourceFile, namedExpr
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10785,7 +11549,7 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBufferFromHelper(
       expression.expression,
       sourceFile,
@@ -10794,7 +11558,7 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10824,10 +11588,10 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
 }
 function expressionLooksLikeJsonObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "JSON") {
+  if (ts6.isIdentifier(expression) && expression.text === "JSON") {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonObjectSource(
       expression.expression,
       sourceFile,
@@ -10844,7 +11608,7 @@ function expressionLooksLikeJsonObjectSource(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10891,7 +11655,7 @@ function expressionLooksLikeJsonStringifyHelper(expression, sourceFile, namedExp
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonStringifyHelper(
       expression.expression,
       sourceFile,
@@ -10900,7 +11664,7 @@ function expressionLooksLikeJsonStringifyHelper(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10948,7 +11712,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonParseHelper(
       expression.expression,
       sourceFile,
@@ -10957,7 +11721,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10987,7 +11751,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
 }
 function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "structuredClone") {
+  if (ts6.isIdentifier(expression) && expression.text === "structuredClone") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "structuredClone") && expressionLooksLikeWindowObjectSource(
@@ -11007,7 +11771,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeStructuredCloneHelper(
       expression.expression,
       sourceFile,
@@ -11016,7 +11780,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11045,7 +11809,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
 }
 function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "Symbol") {
+  if (ts6.isIdentifier(expression) && expression.text === "Symbol") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Symbol") && expressionLooksLikeWindowObjectSource(
@@ -11065,7 +11829,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalSymbolHelper(
       expression.expression,
       sourceFile,
@@ -11074,7 +11838,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11103,7 +11867,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "BigInt") {
+  if (ts6.isIdentifier(expression) && expression.text === "BigInt") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "BigInt") && expressionLooksLikeWindowObjectSource(
@@ -11123,7 +11887,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBigIntHelper(
       expression.expression,
       sourceFile,
@@ -11132,7 +11896,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11161,7 +11925,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "Boolean") {
+  if (ts6.isIdentifier(expression) && expression.text === "Boolean") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Boolean") && expressionLooksLikeWindowObjectSource(
@@ -11181,7 +11945,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBooleanHelper(
       expression.expression,
       sourceFile,
@@ -11190,7 +11954,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11219,7 +11983,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
 }
 function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "Number") {
+  if (ts6.isIdentifier(expression) && expression.text === "Number") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Number") && expressionLooksLikeWindowObjectSource(
@@ -11239,7 +12003,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalNumberHelper(
       expression.expression,
       sourceFile,
@@ -11248,7 +12012,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11277,7 +12041,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "Object") {
+  if (ts6.isIdentifier(expression) && expression.text === "Object") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Object") && expressionLooksLikeWindowObjectSource(
@@ -11297,7 +12061,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalObjectHelper(
       expression.expression,
       sourceFile,
@@ -11306,7 +12070,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11335,7 +12099,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && expression.text === "String") {
+  if (ts6.isIdentifier(expression) && expression.text === "String") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "String") && expressionLooksLikeWindowObjectSource(
@@ -11355,7 +12119,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalStringHelper(
       expression.expression,
       sourceFile,
@@ -11364,7 +12128,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11393,7 +12157,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && ["atob", "btoa"].includes(expression.text)) {
+  if (ts6.isIdentifier(expression) && ["atob", "btoa"].includes(expression.text)) {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "atob", "btoa") && expressionLooksLikeWindowObjectSource(
@@ -11413,7 +12177,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBase64Helper(
       expression.expression,
       sourceFile,
@@ -11422,7 +12186,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11451,7 +12215,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isIdentifier(expression) && [
+  if (ts6.isIdentifier(expression) && [
     "decodeURI",
     "decodeURIComponent",
     "encodeURI",
@@ -11486,7 +12250,7 @@ function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile,
   )) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalUriCodecHelper(
       expression.expression,
       sourceFile,
@@ -11495,7 +12259,7 @@ function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile,
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11534,7 +12298,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
   if (LOCATION_URL_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationUrlSource(
       expression.expression,
       sourceFile,
@@ -11543,7 +12307,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
       seenIdentifiers
     );
   }
-  if (ts3.isNewExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "URL") {
+  if (ts6.isNewExpression(expression) && ts6.isIdentifier(expression.expression) && expression.expression.text === "URL") {
     return expressionLooksLikeLocationUrlInput(
       expression.arguments?.[0],
       sourceFile,
@@ -11552,7 +12316,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -11574,7 +12338,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   if (LOCATION_URL_INPUT_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationUrlInput(
       expression.expression,
       sourceFile,
@@ -11592,7 +12356,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "String" && expression.arguments.length > 0 && (expressionLooksLikeLocationObjectSource(
+  if (isCallLikeExpression(expression) && ts6.isIdentifier(expression.expression) && expression.expression.text === "String" && expression.arguments.length > 0 && (expressionLooksLikeLocationObjectSource(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -11645,7 +12409,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11692,7 +12456,7 @@ function expressionLooksLikeRequestObjectSource(expression, sourceFile, namedExp
   if (REQUEST_OBJECT_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeRequestObjectSource(
       expression.expression,
       sourceFile,
@@ -11700,7 +12464,7 @@ function expressionLooksLikeRequestObjectSource(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -11721,7 +12485,7 @@ function expressionLooksLikeNextUrlSource(expression, sourceFile, namedExpressio
   if (NEXT_URL_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeNextUrlSource(
       expression.expression,
       sourceFile,
@@ -11747,7 +12511,7 @@ function expressionLooksLikeNextUrlSource(expression, sourceFile, namedExpressio
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11781,7 +12545,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
   if (/\b(?:searchParams|(?:request|req)\.nextUrl\.searchParams|url\.searchParams)\b/i.test(text)) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectSearchParamsCarrier(
       expression.expression,
       sourceFile,
@@ -11790,7 +12554,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (ts3.isNewExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "URLSearchParams") {
+  if (ts6.isNewExpression(expression) && ts6.isIdentifier(expression.expression) && expression.expression.text === "URLSearchParams") {
     return expressionLooksLikeLocationQuerySource(
       expression.arguments?.[0],
       sourceFile,
@@ -11799,7 +12563,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useSearchParams" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useSearchParams"))) {
+  if (isCallLikeExpression(expression) && (ts6.isIdentifier(expression.expression) && expression.expression.text === "useSearchParams" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useSearchParams"))) {
     return true;
   }
   if (isPropertyLikeAccessExpression(expression) && isPropertyNamed(expression.name, "searchParams")) {
@@ -11817,7 +12581,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11857,7 +12621,7 @@ function expressionLooksLikeLocationAssignmentTarget(expression, sourceFile, nam
   if (isLocationAssignmentTarget(expression)) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationAssignmentTarget(
       expression.expression,
       sourceFile,
@@ -11879,7 +12643,7 @@ function expressionLooksLikeLocationAssignmentTarget(expression, sourceFile, nam
 }
 function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationMutationCall(
       expression.expression,
       sourceFile,
@@ -11906,7 +12670,7 @@ function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedEx
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -11945,7 +12709,7 @@ function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedEx
 }
 function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeWindowOpenCall(
       expression.expression,
       sourceFile,
@@ -11963,10 +12727,10 @@ function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressi
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression) && expression.text === "open") {
+  if (ts6.isIdentifier(expression) && expression.text === "open") {
     return true;
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -12002,7 +12766,7 @@ function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressi
 }
 function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeHistoryMutationCall(
       expression.expression,
       sourceFile,
@@ -12029,7 +12793,7 @@ function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -12068,7 +12832,7 @@ function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExp
 }
 function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return expressionLooksLikeRouteTransitionCall(
       expression.expression,
       sourceFile,
@@ -12095,7 +12859,7 @@ function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (["redirect", "navigate"].includes(expression.text)) {
       return true;
     }
@@ -12141,7 +12905,7 @@ function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExp
   );
 }
 function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeRouteTransitionCall(
+  if (isMemberAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeRouteTransitionCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -12186,7 +12950,7 @@ function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions,
   )) {
     return getAliasedApplyArgumentExpression(node.arguments[1], 2, namedExpressions, /* @__PURE__ */ new Set());
   }
-  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeHistoryMutationCall(
+  if (isMemberAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeHistoryMutationCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -12217,7 +12981,7 @@ function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions,
 }
 function getAliasedApplyArgumentExpression(expression, index, namedExpressions, seenIdentifiers) {
   if (!expression) return void 0;
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts6.isParenthesizedExpression(expression) || ts6.isAsExpression(expression) || ts6.isTypeAssertionExpression(expression) || ts6.isNonNullExpression(expression)) {
     return getAliasedApplyArgumentExpression(
       expression.expression,
       index,
@@ -12225,7 +12989,7 @@ function getAliasedApplyArgumentExpression(expression, index, namedExpressions,
       seenIdentifiers
     );
   }
-  if (ts3.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return void 0;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return void 0;
@@ -12239,12 +13003,12 @@ function getAliasedApplyArgumentExpression(expression, index, namedExpressions,
     seenIdentifiers.delete(expression.text);
     return result;
   }
-  if (!ts3.isArrayLiteralExpression(expression)) return void 0;
+  if (!ts6.isArrayLiteralExpression(expression)) return void 0;
   const argument = expression.elements[index];
-  return ts3.isExpression(argument) ? argument : void 0;
+  return ts6.isExpression(argument) ? argument : void 0;
 }
 function getLocationMutationTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeLocationMutationCall(
+  if (isMemberAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeLocationMutationCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -12283,7 +13047,7 @@ function getLocationMutationTargetExpression(node, sourceFile, namedExpressions,
   return void 0;
 }
 function getWindowOpenTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeWindowOpenCall(
+  if (isMemberAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeWindowOpenCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -12422,28 +13186,28 @@ var DYNAMIC_GEOMETRY_STYLE_PROPS = /* @__PURE__ */ new Set([
   "y"
 ]);
 function getJsxAttributeExpression(initializer) {
-  if (!initializer || !ts3.isJsxExpression(initializer)) return null;
+  if (!initializer || !ts6.isJsxExpression(initializer)) return null;
   return initializer.expression ?? null;
 }
 function getStylePropertyName(name) {
-  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+  if (ts6.isIdentifier(name) || ts6.isStringLiteral(name) || ts6.isNumericLiteral(name)) {
     return name.text;
   }
-  if (ts3.isComputedPropertyName(name)) {
+  if (ts6.isComputedPropertyName(name)) {
     return getExpressionLiteralValue(name.expression);
   }
   return null;
 }
 function unwrapStyleExpression(expression) {
   let current = expression;
-  while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isTypeAssertionExpression(current) || ts3.isNonNullExpression(current) || ts3.isSatisfiesExpression(current)) {
+  while (ts6.isParenthesizedExpression(current) || ts6.isAsExpression(current) || ts6.isTypeAssertionExpression(current) || ts6.isNonNullExpression(current) || ts6.isSatisfiesExpression(current)) {
     current = current.expression;
   }
   return current;
 }
 function isDynamicStyleValue(expression) {
   const unwrapped = unwrapStyleExpression(expression);
-  if (ts3.isStringLiteral(unwrapped) || ts3.isNoSubstitutionTemplateLiteral(unwrapped) || ts3.isNumericLiteral(unwrapped) || unwrapped.kind === ts3.SyntaxKind.TrueKeyword || unwrapped.kind === ts3.SyntaxKind.FalseKeyword || unwrapped.kind === ts3.SyntaxKind.NullKeyword) {
+  if (ts6.isStringLiteral(unwrapped) || ts6.isNoSubstitutionTemplateLiteral(unwrapped) || ts6.isNumericLiteral(unwrapped) || unwrapped.kind === ts6.SyntaxKind.TrueKeyword || unwrapped.kind === ts6.SyntaxKind.FalseKeyword || unwrapped.kind === ts6.SyntaxKind.NullKeyword) {
     return false;
   }
   return true;
@@ -12452,7 +13216,7 @@ function isAllowedInlineStyleObject(objectLiteral) {
   let sawGeometryProperty = false;
   let sawDynamicGeometryValue = false;
   for (const property of objectLiteral.properties) {
-    if (!ts3.isPropertyAssignment(property)) return false;
+    if (!ts6.isPropertyAssignment(property)) return false;
     const propertyName2 = getStylePropertyName(property.name);
     if (!propertyName2) return false;
     if (propertyName2.startsWith("--d-")) {
@@ -12481,10 +13245,10 @@ function isAllowedInlineStyleAttribute(attribute, sourceFile, namedExpressions,
   return resolved ? isAllowedInlineStyleObject(resolved.objectLiteral) : false;
 }
 function analyzeAstSignals(filePath, code) {
-  const sourceFile = ts3.createSourceFile(
+  const sourceFile = ts6.createSourceFile(
     filePath,
     code,
-    ts3.ScriptTarget.Latest,
+    ts6.ScriptTarget.Latest,
     true,
     getScriptKind(filePath)
   );
@@ -12569,7 +13333,7 @@ function analyzeAstSignals(filePath, code) {
   let navigationLandmarkCount = 0;
   let unlabeledNavigationLandmarkCount = 0;
   const walk = (node) => {
-    if (ts3.isJsxAttribute(node)) {
+    if (ts6.isJsxAttribute(node)) {
       if (isPropertyNamed(node.name, "style") && node.initializer) {
         if (!isAllowedInlineStyleAttribute(
           node,
@@ -12583,7 +13347,7 @@ function analyzeAstSignals(filePath, code) {
       if (isPropertyNamed(node.name, "dangerouslySetInnerHTML") && !isSafeJsonLdDangerouslySetInnerHtml(node)) {
         signals.dangerousHtmlCount += 1;
       }
-      if (isPropertyNamed(node.name, "href", "to") && node.initializer && ts3.isJsxExpression(node.initializer) && expressionContainsOpenRedirectSource(
+      if (isPropertyNamed(node.name, "href", "to") && node.initializer && ts6.isJsxExpression(node.initializer) && expressionContainsOpenRedirectSource(
         node.initializer.expression,
         sourceFile,
         namedExpressionInitializers,
@@ -12601,10 +13365,10 @@ function analyzeAstSignals(filePath, code) {
         signals.authProviderNonceMissingCount += 1;
       }
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "innerHTML", "outerHTML")) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && ts6.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "innerHTML", "outerHTML")) {
       signals.rawHtmlInjectionCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -12618,7 +13382,7 @@ function analyzeAstSignals(filePath, code) {
     )) {
       signals.authOpenRedirectSignalCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -12627,7 +13391,7 @@ function analyzeAstSignals(filePath, code) {
     ) && isInsecureTransportUrl(getExpressionLiteralValue(node.right))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -12645,7 +13409,7 @@ function analyzeAstSignals(filePath, code) {
         signals.authProviderNonceMissingCount += 1;
       }
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -12659,36 +13423,36 @@ function analyzeAstSignals(filePath, code) {
     )) {
       signals.authOpenRedirectSignalCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "onmessage")) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && ts6.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "onmessage")) {
       const handler = resolveFunctionLikeHandler(node.right, namedFunctionDeclarations);
       if (handler && !functionLikeReferencesOrigin(handler)) {
         signals.messageListenerWithoutOriginCheckCount += 1;
       }
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && /(?:token|auth|jwt|session)/i.test(node.left.name.text)) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && ts6.isPropertyAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && /(?:token|auth|jwt|session)/i.test(node.left.name.text)) {
       signals.authStorageWriteCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isElementAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && isAuthStorageKeyLiteral(node.left.argumentExpression)) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && ts6.isElementAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && isAuthStorageKeyLiteral(node.left.argumentExpression)) {
       signals.authStorageWriteCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && isCookiePropertyAccess(node.left) && hasAuthCredentialText(node.right, sourceFile)) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && isCookiePropertyAccess(node.left) && hasAuthCredentialText(node.right, sourceFile)) {
       signals.authCookieWriteCount += 1;
     }
-    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && isAuthorizationHeaderAccess(node.left)) {
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && isAuthorizationHeaderAccess(node.left)) {
       if (isHeaderClearValue(node.right)) {
         signals.authHeaderClearCount += 1;
       } else {
         signals.authHeaderWriteCount += 1;
       }
     }
-    if (ts3.isPropertyAssignment(node) && isAuthorizationHeaderName(node.name)) {
+    if (ts6.isPropertyAssignment(node) && isAuthorizationHeaderName(node.name)) {
       if (isHeaderClearValue(node.initializer)) {
         signals.authHeaderClearCount += 1;
       } else {
         signals.authHeaderWriteCount += 1;
       }
     }
-    if (ts3.isDeleteExpression(node) && isAuthorizationHeaderAccess(node.expression)) {
+    if (ts6.isDeleteExpression(node) && isAuthorizationHeaderAccess(node.expression)) {
       signals.authHeaderClearCount += 1;
     }
     if (isCallLikeExpression(node)) {
@@ -12719,10 +13483,10 @@ function analyzeAstSignals(filePath, code) {
         namedPropertyAliases
       );
       const windowOpenTargetLiteral = getExpressionLiteralValue(windowOpenTargetExpression);
-      if (ts3.isIdentifier(node.expression) && node.expression.text === "eval") {
+      if (ts6.isIdentifier(node.expression) && node.expression.text === "eval") {
         signals.dynamicEvalCount += 1;
       }
-      if ((ts3.isIdentifier(node.expression) && ["setTimeout", "setInterval"].includes(node.expression.text) || ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "setTimeout", "setInterval")) && typeof firstArgumentLiteral === "string") {
+      if ((ts6.isIdentifier(node.expression) && ["setTimeout", "setInterval"].includes(node.expression.text) || ts6.isPropertyAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "setTimeout", "setInterval")) && typeof firstArgumentLiteral === "string") {
         signals.dynamicEvalCount += 1;
       }
       if ((isFetchLikeCall(node) || isAxiosLikeCall(node)) && isInsecureTransportUrl(firstArgumentLiteral)) {
@@ -12804,7 +13568,7 @@ function analyzeAstSignals(filePath, code) {
           signals.authProviderNonceMissingCount += 1;
         }
       }
-      if (ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "postMessage") && secondArgumentLiteral === "*") {
+      if (ts6.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "postMessage") && secondArgumentLiteral === "*") {
         signals.wildcardPostMessageCount += 1;
       }
       if (isAddEventListenerCall(node) && firstArgumentLiteral === "message") {
@@ -12813,7 +13577,7 @@ function analyzeAstSignals(filePath, code) {
           signals.messageListenerWithoutOriginCheckCount += 1;
         }
       }
-      if (ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "setHeader", "append", "set") && isSetCookieHeaderName(node.arguments[0])) {
+      if (ts6.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "setHeader", "append", "set") && isSetCookieHeaderName(node.arguments[0])) {
         const cookieStrings = collectCookieHeaderStrings(node.arguments[1]);
         const authCookieStrings = cookieStrings.filter(cookieHeaderStringLooksAuthLike);
         if (authCookieStrings.length > 0) {
@@ -12831,13 +13595,13 @@ function analyzeAstSignals(filePath, code) {
           }
         }
       }
-      if ((ts3.isIdentifier(node.expression) && node.expression.text === "open" || ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "open")) && secondArgumentLiteral === "_blank") {
+      if ((ts6.isIdentifier(node.expression) && node.expression.text === "open" || ts6.isPropertyAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "open")) && secondArgumentLiteral === "_blank") {
         const featureLiteral = getExpressionLiteralValue(node.arguments[2])?.toLowerCase() ?? "";
         if (!featureLiteral.includes("noopener") || !featureLiteral.includes("noreferrer")) {
           signals.windowOpenWithoutNoopenerCount += 1;
         }
       }
-      if (ts3.isPropertyAccessExpression(node.expression)) {
+      if (ts6.isPropertyAccessExpression(node.expression)) {
         if (isPropertyNamed(node.expression.name, "insertAdjacentHTML")) {
           signals.rawHtmlInjectionCount += 1;
         }
@@ -12846,7 +13610,7 @@ function analyzeAstSignals(filePath, code) {
         }
         if (isCookieMutationSetCall(node)) {
           const firstArgument = node.arguments[0];
-          const isObjectConfigCall = ts3.isObjectLiteralExpression(firstArgument);
+          const isObjectConfigCall = ts6.isObjectLiteralExpression(firstArgument);
           const isAuthCookieWrite = isObjectConfigCall ? objectLiteralLooksLikeAuthCookieConfig(firstArgument, sourceFile) : expressionLooksLikeAuthCookieName(firstArgument, sourceFile);
           if (isAuthCookieWrite) {
             signals.authCookieWriteCount += 1;
@@ -12866,7 +13630,7 @@ function analyzeAstSignals(filePath, code) {
             signals.authHeaderWriteCount += 1;
           }
         }
-        if (ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "document" && isPropertyNamed(node.expression.name, "write")) {
+        if (ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "document" && isPropertyNamed(node.expression.name, "write")) {
           signals.rawHtmlInjectionCount += 1;
         }
         if (isPropertyNamed(node.expression.name, "eval")) {
@@ -12874,16 +13638,16 @@ function analyzeAstSignals(filePath, code) {
         }
       }
     }
-    if (ts3.isNewExpression(node) && isRealtimeTransportConstructor(node) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
+    if (ts6.isNewExpression(node) && isRealtimeTransportConstructor(node) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts3.isNewExpression(node) && ts3.isIdentifier(node.expression) && node.expression.text === "Function") {
+    if (ts6.isNewExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === "Function") {
       signals.dynamicEvalCount += 1;
     }
-    if (ts3.isNewExpression(node) && ts3.isIdentifier(node.expression) && ["WebSocket", "EventSource"].includes(node.expression.text) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
+    if (ts6.isNewExpression(node) && ts6.isIdentifier(node.expression) && ["WebSocket", "EventSource"].includes(node.expression.text) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts3.isJsxSelfClosingElement(node)) {
+    if (ts6.isJsxSelfClosingElement(node)) {
       const tagName = getJsxTagName(node);
       if (hasMainLandmarkSignal(node.attributes, tagName)) {
         signals.mainLandmarkCount += 1;
@@ -12976,7 +13740,7 @@ function analyzeAstSignals(filePath, code) {
         signals.formControlWithoutLabelCount += 1;
       }
     }
-    if (ts3.isJsxElement(node)) {
+    if (ts6.isJsxElement(node)) {
       const tagName = getJsxTagName(node.openingElement);
       const textContent = getJsxTextContent(node).replace(/\s+/g, " ").trim();
       if (hasMainLandmarkSignal(node.openingElement.attributes, tagName)) {
@@ -13092,7 +13856,7 @@ function analyzeAstSignals(filePath, code) {
         signals.formControlWithoutLabelCount += 1;
       }
     }
-    ts3.forEachChild(node, walk);
+    ts6.forEachChild(node, walk);
   };
   walk(sourceFile);
   signals.unlabeledNavigationLandmarkCount = navigationLandmarkCount > 1 ? unlabeledNavigationLandmarkCount : 0;
@@ -14846,11 +15610,11 @@ function critiqueSource({
   };
 }
 function resolveProjectFilePath(projectRoot, filePath) {
-  const root = existsSync4(projectRoot) ? realpathSync.native(projectRoot) : resolve(projectRoot);
-  const candidatePath = isAbsolute2(filePath) ? resolve(filePath) : resolve(root, filePath);
-  const resolvedPath = existsSync4(candidatePath) ? realpathSync.native(candidatePath) : candidatePath;
-  const relativePath = relative4(root, resolvedPath);
-  if (relativePath.startsWith("..") || isAbsolute2(relativePath)) {
+  const root = existsSync6(projectRoot) ? realpathSync2.native(projectRoot) : resolve3(projectRoot);
+  const candidatePath = isAbsolute4(filePath) ? resolve3(filePath) : resolve3(root, filePath);
+  const resolvedPath = existsSync6(candidatePath) ? realpathSync2.native(candidatePath) : candidatePath;
+  const relativePath = relative6(root, resolvedPath);
+  if (relativePath.startsWith("..") || isAbsolute4(relativePath)) {
     throw new Error(`Path escapes the project root: ${filePath}`);
   }
   return resolvedPath;
@@ -14858,7 +15622,7 @@ function resolveProjectFilePath(projectRoot, filePath) {
 async function critiqueFile(filePath, projectRoot) {
   const resolvedPath = resolveProjectFilePath(projectRoot, filePath);
   const code = await readFile(resolvedPath, "utf-8");
-  const treatmentsCss = readTextIfExists(join4(projectRoot, "src", "styles", "treatments.css"));
+  const treatmentsCss = readTextIfExists(join6(projectRoot, "src", "styles", "treatments.css"));
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
   const adoptionMode = readProjectAdoptionMode(projectRoot);
@@ -14888,19 +15652,33 @@ export {
   buildProjectHealthRepairPlan,
   collectMissingPackManifestFiles,
   collectProjectSourceFiles,
+  collectSourceImports,
   createContractAssertions,
   createEvidenceBundle,
+  createProjectSourceProgram,
+  createSourceInventory,
   createUnavailableScanReport,
   critiqueFile,
   critiqueSource,
   deriveVerificationDiagnostic,
   emptyRuntimeAudit,
   extractRouteHintsFromEssence,
+  extractSourceStringLiterals,
+  getProjectSourceFile,
+  isPathInsideProject,
+  isSupportedSourceExtension,
   listKnownInteractions,
+  normalizeSourcePath,
   probePublishedSite,
   resolveGitHubScanInput,
   resolveGraphAnchorForFinding,
+  resolveSourceImport,
+  resolveSourceSymbolOrigin,
   scanProject,
+  sourceKindFromPath,
+  sourceLanguageFromPath,
+  sourceLocationForNode,
+  sourceScriptKindFromPath,
   verifyInteractionsInSource
 };
 //# sourceMappingURL=index.js.map