obsidian-dev-utils 76.1.0 → 77.1.0

package/dist/lib/esm/script-utils/linters/over-exposure.mjs

@@ -0,0 +1,370 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  canHaveModifiers,
+  createDocumentRegistry,
+  createLanguageService,
+  getDefaultLibFilePath,
+  getModifiers,
+  isClassDeclaration,
+  isClassLike,
+  isEnumDeclaration,
+  isFunctionDeclaration,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isInterfaceDeclaration,
+  isMethodDeclaration,
+  isPropertyDeclaration,
+  isSetAccessorDeclaration,
+  isSourceFile,
+  isTypeAliasDeclaration,
+  isVariableStatement,
+  ScriptSnapshot,
+  SyntaxKind,
+  sys
+} from "typescript";
+import { assertNonNullable } from "../../type-guards.mjs";
+import {
+  parseTsConfig,
+  toCanonical
+} from "../check-project-types.mjs";
+const LIFECYCLE_ALLOWLIST = /* @__PURE__ */ new Set([
+  "display",
+  "hide",
+  "onExternalSettingsChange",
+  "onLayoutReady",
+  "onload",
+  "onloadImpl",
+  "onLoadSettings",
+  "onSaveSettings",
+  "onunload",
+  "onunloadImpl"
+]);
+const MEMBER_EXPOSURE_ORDER = ["private", "protected", "public"];
+const SCOPE_DESCRIPTION = {
+  "file-local": "within its own file",
+  "private": "inside its own class",
+  "protected": "inside its class + subclasses"
+};
+function analyzeOverExposure(params) {
+  const { languageService, onProgress, srcFolder } = params;
+  const program = languageService.getProgram();
+  if (!program) {
+    return [];
+  }
+  const context = {
+    checker: program.getTypeChecker(),
+    findings: [],
+    languageService,
+    program
+  };
+  const sourceFilesToAnalyze = program.getSourceFiles().filter((sourceFile) => {
+    const filePath = toCanonical(sourceFile.fileName);
+    return isOwnSourceFile(filePath, srcFolder) && !isTestFile(filePath);
+  });
+  for (const [analyzedFileCount, sourceFile] of sourceFilesToAnalyze.entries()) {
+    onProgress?.({
+      analyzedFileCount,
+      currentFilePath: toCanonical(sourceFile.fileName),
+      totalFileCount: sourceFilesToAnalyze.length
+    });
+    visit(sourceFile);
+  }
+  return context.findings;
+  function visit(node) {
+    analyzeMember(node, context);
+    analyzeExport(node, context);
+    node.forEachChild(visit);
+  }
+}
+function createLanguageServiceHost(params) {
+  const { compilerOptions, fileNames, fileSystem } = params;
+  return {
+    directoryExists: (directory) => fileSystem.directoryExists(directory),
+    fileExists: (file) => fileSystem.fileExists(file),
+    getCompilationSettings: () => compilerOptions,
+    getCurrentDirectory: () => fileSystem.getCurrentDirectory(),
+    getDefaultLibFileName: (libOptions) => getDefaultLibFilePath(libOptions),
+    getDirectories: (directory) => fileSystem.getDirectories(directory),
+    getScriptFileNames: () => [...fileNames],
+    getScriptSnapshot: (fileName) => {
+      const text = fileSystem.readFile(fileName);
+      return text === void 0 ? void 0 : ScriptSnapshot.fromString(text);
+    },
+    getScriptVersion: () => "0",
+    readDirectory: (path, extensions, exclude, include, depth) => fileSystem.readDirectory(path, extensions, exclude, include, depth),
+    readFile: (file) => fileSystem.readFile(file)
+  };
+}
+function createProjectLanguageService(params) {
+  const { fileNames, options } = parseTsConfig(params.tsConfigPath);
+  return createLanguageService(createLanguageServiceHost({ compilerOptions: options, fileNames, fileSystem: sys }), createDocumentRegistry());
+}
+function findOverExposure(params) {
+  const projectFolder = toCanonical(params.projectFolder);
+  const languageService = createProjectLanguageService({ tsConfigPath: `${projectFolder}/tsconfig.json` });
+  return analyzeOverExposure({
+    languageService,
+    srcFolder: `${projectFolder}/src`,
+    ...params.onProgress ? { onProgress: params.onProgress } : {}
+  });
+}
+function formatOverExposureFindings(findings, options) {
+  if (findings.length === 0) {
+    return "No over-exposed declarations found.\n";
+  }
+  const baseFolder = options?.baseFolder === void 0 ? void 0 : toCanonical(options.baseFolder);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const list = byFile.get(finding.filePath) ?? [];
+    list.push(finding);
+    byFile.set(finding.filePath, list);
+  }
+  const lines = [];
+  for (const [filePath, list] of byFile) {
+    const displayPath = toDisplayPath(filePath, baseFolder);
+    for (const finding of [...list].sort((a, b) => a.line - b.line)) {
+      const location = `${displayPath}:${String(finding.line)}:${String(finding.column)}`;
+      const change = `${finding.currentExposure} ${finding.name} -> ${finding.suggestedExposure}`;
+      lines.push(location, `${change} -- ${describeReason(finding)}`, "");
+    }
+  }
+  lines.push(`${String(findings.length)} finding(s).`);
+  return `${lines.join("\n")}
+`;
+}
+function analyzeExport(node, context) {
+  const sourceFile = node.getSourceFile();
+  if (node.parent !== sourceFile || !getModifierKinds(node).has(SyntaxKind.ExportKeyword)) {
+    return;
+  }
+  const declFilePath = toCanonical(sourceFile.fileName);
+  for (const nameNode of getExportedNameNodes(node)) {
+    const references = collectReferences(context.languageService.findReferences(sourceFile.fileName, nameNode.getStart())).filter((reference) => !isDeclarationItself(reference, nameNode));
+    const otherFileReferences = references.filter((reference) => toCanonical(reference.fileName) !== declFilePath);
+    if (otherFileReferences.length === 0) {
+      context.findings.push(buildFinding(node, nameNode, "export", "file-local", { hasNoReferences: references.length === 0, isForcedByTestOnly: false }));
+      continue;
+    }
+    const nonTestReferences = otherFileReferences.filter((reference) => !isTestFile(toCanonical(reference.fileName)));
+    if (nonTestReferences.length === 0) {
+      context.findings.push(buildFinding(node, nameNode, "export", "file-local", { hasNoReferences: false, isForcedByTestOnly: true }));
+    }
+  }
+}
+function analyzeMember(node, context) {
+  const nameNode = getMemberNameNode(node);
+  if (!nameNode || !isClassLike(node.parent)) {
+    return;
+  }
+  const declaringClass = node.parent;
+  const modifierKinds = getModifierKinds(node);
+  if (modifierKinds.has(SyntaxKind.StaticKeyword) || modifierKinds.has(SyntaxKind.OverrideKeyword) || LIFECYCLE_ALLOWLIST.has(nameNode.getText())) {
+    return;
+  }
+  const currentExposure = getCurrentMemberExposure(modifierKinds);
+  if (currentExposure === "private") {
+    return;
+  }
+  const sourceFile = node.getSourceFile();
+  const references = collectReferences(context.languageService.findReferences(sourceFile.fileName, nameNode.getStart())).filter((reference) => !isDeclarationItself(reference, nameNode));
+  const nonTestReferences = references.filter((reference) => !isTestFile(toCanonical(reference.fileName)));
+  const neededForSrc = computeNeededExposure(nonTestReferences, declaringClass, context);
+  const neededWithTests = computeNeededExposure(references, declaringClass, context);
+  if (neededForSrc === "public") {
+    return;
+  }
+  if (rankExposure(neededForSrc) >= rankExposure(currentExposure)) {
+    return;
+  }
+  context.findings.push(buildFinding(node, nameNode, currentExposure, neededForSrc, {
+    hasNoReferences: references.length === 0,
+    isForcedByTestOnly: rankExposure(neededWithTests) > rankExposure(neededForSrc)
+  }));
+}
+function buildFinding(node, nameNode, currentExposure, suggestedExposure, flags) {
+  const sourceFile = node.getSourceFile();
+  const { character, line } = sourceFile.getLineAndCharacterOfPosition(nameNode.getStart());
+  return {
+    column: character + 1,
+    currentExposure,
+    filePath: toCanonical(sourceFile.fileName),
+    hasNoReferences: flags.hasNoReferences,
+    isForcedByTestOnly: flags.isForcedByTestOnly,
+    isMember: currentExposure !== "export",
+    line: line + 1,
+    name: nameNode.getText(),
+    suggestedExposure
+  };
+}
+function collectReferences(referencedSymbols) {
+  const references = [];
+  for (const referencedSymbol of referencedSymbols ?? []) {
+    for (const reference of referencedSymbol.references) {
+      references.push({ fileName: reference.fileName, start: reference.textSpan.start });
+    }
+  }
+  return references;
+}
+function computeNeededExposure(references, declaringClass, context) {
+  if (references.length === 0) {
+    return "private";
+  }
+  let needed = "private";
+  for (const reference of references) {
+    const referenceClass = getClassAtPosition(context.program, reference.fileName, reference.start);
+    if (referenceClass === declaringClass) {
+      continue;
+    }
+    if (referenceClass && isDerivedFrom(referenceClass, declaringClass, context.checker)) {
+      needed = "protected";
+      continue;
+    }
+    return "public";
+  }
+  return needed;
+}
+function describeReason(finding) {
+  const base = `referenced only ${SCOPE_DESCRIPTION[finding.suggestedExposure]}`;
+  if (finding.isForcedByTestOnly) {
+    return `${base} (exposed only for tests)`;
+  }
+  if (finding.hasNoReferences) {
+    return `${base} (no references at all)`;
+  }
+  return base;
+}
+function findNodeAtPosition(node, position) {
+  if (position < node.getStart() || position >= node.getEnd()) {
+    return void 0;
+  }
+  let result = node;
+  node.forEachChild((child) => {
+    const found = findNodeAtPosition(child, position);
+    if (found) {
+      result = found;
+    }
+  });
+  return result;
+}
+function getClassAtPosition(program, fileName, position) {
+  const sourceFile = program.getSourceFile(fileName);
+  assertNonNullable(sourceFile, `Source file not found in program: ${fileName}`);
+  const node = findNodeAtPosition(sourceFile, position);
+  assertNonNullable(node, `No node found at position ${String(position)} in ${fileName}`);
+  return getEnclosingClass(node);
+}
+function getCurrentMemberExposure(modifierKinds) {
+  if (modifierKinds.has(SyntaxKind.PrivateKeyword)) {
+    return "private";
+  }
+  if (modifierKinds.has(SyntaxKind.ProtectedKeyword)) {
+    return "protected";
+  }
+  return "public";
+}
+function getEnclosingClass(node) {
+  let current = node;
+  while (!isSourceFile(current)) {
+    if (isClassLike(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function getExportedNameNodes(node) {
+  if (isFunctionDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isTypeAliasDeclaration(node) || isEnumDeclaration(node)) {
+    return node.name ? [node.name] : [];
+  }
+  if (isVariableStatement(node)) {
+    return node.declarationList.declarations.map((declaration) => declaration.name).filter(isIdentifier);
+  }
+  return [];
+}
+function getMemberNameNode(node) {
+  if (isMethodDeclaration(node) || isPropertyDeclaration(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) {
+    return node.name;
+  }
+  return void 0;
+}
+function getModifierKinds(node) {
+  const kinds = /* @__PURE__ */ new Set();
+  if (canHaveModifiers(node)) {
+    for (const modifier of getModifiers(node) ?? []) {
+      kinds.add(modifier.kind);
+    }
+  }
+  return kinds;
+}
+function isDeclarationItself(reference, nameNode) {
+  return toCanonical(reference.fileName) === toCanonical(nameNode.getSourceFile().fileName) && reference.start === nameNode.getStart();
+}
+function isDerivedFrom(derived, base, checker) {
+  const baseSymbol = base.name ? checker.getSymbolAtLocation(base.name) : void 0;
+  if (!baseSymbol) {
+    return false;
+  }
+  for (const clause of derived.heritageClauses ?? []) {
+    if (clause.token !== SyntaxKind.ExtendsKeyword) {
+      continue;
+    }
+    for (const typeExpression of clause.types) {
+      const symbol = checker.getTypeAtLocation(typeExpression.expression).getSymbol();
+      if (symbol === baseSymbol) {
+        return true;
+      }
+      for (const declaration of symbol?.declarations ?? []) {
+        if (isClassLike(declaration) && isDerivedFrom(declaration, base, checker)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isOwnSourceFile(filePath, srcFolder) {
+  return filePath.startsWith(`${srcFolder}/`) && filePath.endsWith(".ts") && !filePath.endsWith(".d.ts");
+}
+function isTestFile(filePath) {
+  return filePath.includes(".test.") || filePath.includes(".integration.");
+}
+function rankExposure(exposure) {
+  return MEMBER_EXPOSURE_ORDER.indexOf(exposure);
+}
+function toDisplayPath(filePath, baseFolder) {
+  if (baseFolder !== void 0 && filePath.startsWith(`${baseFolder}/`)) {
+    return filePath.slice(baseFolder.length + 1);
+  }
+  return filePath;
+}
+export {
+  LIFECYCLE_ALLOWLIST,
+  analyzeOverExposure,
+  createLanguageServiceHost,
+  createProjectLanguageService,
+  findOverExposure,
+  formatOverExposureFindings
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/linters/over-exposure.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Over-exposure analyzer.\n *\n * Finds declarations exposed more broadly than their references require, so the exposure can be\n * tightened:\n *\n * - `export`ed symbols referenced only within their own file \u2014 the `export` can be dropped.\n * - `public` class members referenced only inside their own class \u2014 they can be `private`.\n * - `public` class members referenced only inside their own class and its subclasses \u2014 they can be\n *   `protected`.\n * - `protected` class members referenced only inside their own class \u2014 they can be `private`.\n *\n * The analysis is whole-program and type-aware: it uses the TypeScript language service's\n * find-all-references to locate every use of each declaration, then classifies the tightest\n * exposure that still covers all references. Members invoked by the framework via registration\n * rather than by visible references (Obsidian lifecycle hooks, settings-tab `display`, etc.) are\n * excluded via {@link LIFECYCLE_ALLOWLIST}, as are `override` and `static` members whose exposure is\n * constrained by a base declaration.\n *\n * A member referenced only from test files is reported with {@link OverExposureFinding.isForcedByTestOnly}\n * set, surfacing members widened purely for testability \u2014 the canonical case for extracting logic\n * into an independently testable component instead.\n */\n\nimport type {\n  ClassLikeDeclaration,\n  CompilerOptions,\n  IScriptSnapshot,\n  LanguageService,\n  LanguageServiceHost,\n  Node,\n  Program,\n  ReferencedSymbol,\n  TypeChecker\n} from 'typescript';\n\nimport {\n  canHaveModifiers,\n  createDocumentRegistry,\n  createLanguageService,\n  getDefaultLibFilePath,\n  getModifiers,\n  isClassDeclaration,\n  isClassLike,\n  isEnumDeclaration,\n  isFunctionDeclaration,\n  isGetAccessorDeclaration,\n  isIdentifier,\n  isInterfaceDeclaration,\n  isMethodDeclaration,\n  isPropertyDeclaration,\n  isSetAccessorDeclaration,\n  isSourceFile,\n  isTypeAliasDeclaration,\n  isVariableStatement,\n  ScriptSnapshot,\n  SyntaxKind,\n  sys\n} from 'typescript';\n\nimport { assertNonNullable } from '../../type-guards.ts';\nimport {\n  parseTsConfig,\n  toCanonical\n} from '../check-project-types.ts';\n\n/**\n * Parameters for {@link analyzeOverExposure}.\n */\nexport interface AnalyzeOverExposureParams {\n  /** The language service to query for references and types. */\n  readonly languageService: LanguageService;\n\n  /**\n   * Optional callback invoked once per analyzed source file, before that file is processed. The\n   * whole-program reference analysis is slow, so this lets callers report live progress instead of\n   * appearing to hang.\n   */\n  onProgress?(this: void, progress: OverExposureProgress): void;\n\n  /**\n   * Absolute (canonical) path of the project's `src` folder. Only declarations in non-test files\n   * under this folder are analyzed; declarations elsewhere (test files, dependencies) are ignored\n   * but still counted as reference sites.\n   */\n  readonly srcFolder: string;\n}\n\n/**\n * Parameters for {@link createLanguageServiceHost}.\n */\nexport interface CreateLanguageServiceHostParams {\n  /** The compiler options. */\n  readonly compilerOptions: CompilerOptions;\n\n  /** The files to include in the program. */\n  readonly fileNames: readonly string[];\n\n  /** The file-system operations used to read sources. */\n  readonly fileSystem: OverExposureFileSystem;\n}\n\n/**\n * Parameters for {@link createProjectLanguageService}.\n */\nexport interface CreateProjectLanguageServiceParams {\n  /** Absolute path to the project's `tsconfig.json`. */\n  readonly tsConfigPath: string;\n}\n\n/**\n * The exposure level a declaration currently has.\n */\nexport type CurrentExposure = 'export' | 'protected' | 'public';\n\n/**\n * Parameters for {@link findOverExposure}.\n */\nexport interface FindOverExposureParams {\n  /**\n   * Optional callback invoked once per analyzed source file, for live progress reporting. Forwarded\n   * to {@link analyzeOverExposure}.\n   */\n  onProgress?(this: void, progress: OverExposureProgress): void;\n\n  /** Absolute path to the project root (the folder containing `tsconfig.json` and `src`). */\n  readonly projectFolder: string;\n}\n\n/**\n * Options for {@link formatOverExposureFindings}.\n */\nexport interface FormatOverExposureFindingsOptions {\n  /**\n   * When set, file paths in the report are rendered relative to this folder (typically the current\n   * working directory) instead of as absolute paths. Paths outside the folder stay absolute.\n   */\n  readonly baseFolder?: string;\n}\n\n/**\n * The subset of file-system operations the language-service host needs. Injecting this (rather than\n * always using `typescript`'s `sys`) lets tests drive the analyzer against in-memory sources with no\n * real file-system access.\n */\nexport interface OverExposureFileSystem {\n  /**\n   * @param path - Directory path.\n   * @returns `true` when the directory exists.\n   */\n  directoryExists(this: void, path: string): boolean;\n\n  /**\n   * @param path - File path.\n   * @returns `true` when the file exists.\n   */\n  fileExists(this: void, path: string): boolean;\n\n  /**\n   * @returns The current working directory.\n   */\n  getCurrentDirectory(this: void): string;\n\n  /**\n   * @param path - Directory path.\n   * @returns The immediate subdirectory names.\n   */\n  getDirectories(this: void, path: string): string[];\n\n  /**\n   * @param path - Root directory.\n   * @param extensions - Extensions to include.\n   * @param exclude - Patterns to exclude.\n   * @param include - Patterns to include.\n   * @param depth - Maximum recursion depth.\n   * @returns The matching file paths.\n   */\n  readDirectory(this: void, path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];\n\n  /**\n   * @param path - File path.\n   * @returns The file contents, or `undefined` when absent.\n   */\n  readFile(this: void, path: string): string | undefined;\n}\n\n/**\n * A single over-exposed declaration.\n */\nexport interface OverExposureFinding {\n  /** 1-based column of the declaration's name. */\n  readonly column: number;\n\n  /** The current exposure level. */\n  readonly currentExposure: CurrentExposure;\n\n  /** Absolute path of the file declaring the symbol. */\n  readonly filePath: string;\n\n  /** `true` when the declaration has no references at all (besides itself). */\n  readonly hasNoReferences: boolean;\n\n  /**\n   * `true` when the declaration would qualify for a tighter exposure if not for references coming\n   * exclusively from test files \u2014 i.e. it is exposed purely for testability.\n   */\n  readonly isForcedByTestOnly: boolean;\n\n  /** `true` for a class member, `false` for a top-level export. */\n  readonly isMember: boolean;\n\n  /** 1-based line of the declaration's name. */\n  readonly line: number;\n\n  /** The declared name. */\n  readonly name: string;\n\n  /** The exposure the declaration could be tightened to. */\n  readonly suggestedExposure: SuggestedExposure;\n}\n\n/**\n * Progress reported while analyzing a project, one event per analyzed source file.\n */\nexport interface OverExposureProgress {\n  /** Number of source files fully analyzed before the current one (0-based). */\n  readonly analyzedFileCount: number;\n\n  /** Absolute (canonical) path of the source file about to be analyzed. */\n  readonly currentFilePath: string;\n\n  /** Total number of source files that will be analyzed. */\n  readonly totalFileCount: number;\n}\n\n/**\n * The (tighter) exposure level a declaration could be reduced to.\n */\nexport type SuggestedExposure = 'file-local' | 'private' | 'protected';\n\n/**\n * Lifecycle and framework members invoked by Obsidian or a base class via registration rather than\n * by references the language service can see. Tightening these would break the framework contract,\n * so they are never reported.\n */\nexport const LIFECYCLE_ALLOWLIST: ReadonlySet<string> = new Set<string>([\n  'display',\n  'hide',\n  'onExternalSettingsChange',\n  'onLayoutReady',\n  'onload',\n  'onloadImpl',\n  'onLoadSettings',\n  'onSaveSettings',\n  'onunload',\n  'onunloadImpl'\n]);\n\ninterface AnalysisContext {\n  readonly checker: TypeChecker;\n  readonly findings: OverExposureFinding[];\n  readonly languageService: LanguageService;\n  readonly program: Program;\n}\n\ninterface FindingFlags {\n  readonly hasNoReferences: boolean;\n  readonly isForcedByTestOnly: boolean;\n}\n\ntype MemberExposure = 'private' | 'protected' | 'public';\n\ninterface ReferenceLocation {\n  readonly fileName: string;\n  readonly start: number;\n}\n\nconst MEMBER_EXPOSURE_ORDER: readonly MemberExposure[] = ['private', 'protected', 'public'];\nconst SCOPE_DESCRIPTION: Record<SuggestedExposure, string> = {\n  'file-local': 'within its own file',\n  'private': 'inside its own class',\n  'protected': 'inside its class + subclasses'\n};\n\n/**\n * Analyzes a project (already loaded into a language service) for over-exposed declarations.\n *\n * @param params - The {@link AnalyzeOverExposureParams}.\n * @returns The over-exposed declarations, in discovery order.\n */\nexport function analyzeOverExposure(params: AnalyzeOverExposureParams): OverExposureFinding[] {\n  const { languageService, onProgress, srcFolder } = params;\n  const program = languageService.getProgram();\n  if (!program) {\n    return [];\n  }\n\n  const context: AnalysisContext = {\n    checker: program.getTypeChecker(),\n    findings: [],\n    languageService,\n    program\n  };\n\n  const sourceFilesToAnalyze = program.getSourceFiles().filter((sourceFile) => {\n    const filePath = toCanonical(sourceFile.fileName);\n    return isOwnSourceFile(filePath, srcFolder) && !isTestFile(filePath);\n  });\n\n  for (const [analyzedFileCount, sourceFile] of sourceFilesToAnalyze.entries()) {\n    onProgress?.({\n      analyzedFileCount,\n      currentFilePath: toCanonical(sourceFile.fileName),\n      totalFileCount: sourceFilesToAnalyze.length\n    });\n    visit(sourceFile);\n  }\n  return context.findings;\n\n  function visit(node: Node): void {\n    analyzeMember(node, context);\n    analyzeExport(node, context);\n    node.forEachChild(visit);\n  }\n}\n\n/**\n * Builds a {@link LanguageServiceHost} backed by an explicit file list and file system.\n *\n * @param params - The {@link CreateLanguageServiceHostParams}.\n * @returns The language-service host.\n */\nexport function createLanguageServiceHost(params: CreateLanguageServiceHostParams): LanguageServiceHost {\n  const { compilerOptions, fileNames, fileSystem } = params;\n  return {\n    directoryExists: (directory) => fileSystem.directoryExists(directory),\n    fileExists: (file) => fileSystem.fileExists(file),\n    getCompilationSettings: () => compilerOptions,\n    getCurrentDirectory: () => fileSystem.getCurrentDirectory(),\n    getDefaultLibFileName: (libOptions) => getDefaultLibFilePath(libOptions),\n    getDirectories: (directory) => fileSystem.getDirectories(directory),\n    getScriptFileNames: () => [...fileNames],\n    getScriptSnapshot: (fileName): IScriptSnapshot | undefined => {\n      const text = fileSystem.readFile(fileName);\n      return text === undefined ? undefined : ScriptSnapshot.fromString(text);\n    },\n    getScriptVersion: () => '0',\n    readDirectory: (path, extensions, exclude, include, depth) => fileSystem.readDirectory(path, extensions, exclude, include, depth),\n    readFile: (file) => fileSystem.readFile(file)\n  };\n}\n\n/**\n * Builds a language service over every file in a project's `tsconfig.json`.\n *\n * @param params - The {@link CreateProjectLanguageServiceParams}.\n * @returns A language service ready for {@link analyzeOverExposure}.\n */\nexport function createProjectLanguageService(params: CreateProjectLanguageServiceParams): LanguageService {\n  const { fileNames, options } = parseTsConfig(params.tsConfigPath);\n  return createLanguageService(createLanguageServiceHost({ compilerOptions: options, fileNames, fileSystem: sys }), createDocumentRegistry());\n}\n\n/**\n * Finds over-exposed declarations in a project on disk.\n *\n * @param params - The {@link FindOverExposureParams}.\n * @returns The over-exposed declarations.\n */\nexport function findOverExposure(params: FindOverExposureParams): OverExposureFinding[] {\n  const projectFolder = toCanonical(params.projectFolder);\n  const languageService = createProjectLanguageService({ tsConfigPath: `${projectFolder}/tsconfig.json` });\n  return analyzeOverExposure({\n    languageService,\n    srcFolder: `${projectFolder}/src`,\n    ...params.onProgress ? { onProgress: params.onProgress } : {}\n  });\n}\n\n/**\n * Formats over-exposure findings as a human-readable report. Findings are grouped by file and sorted\n * by line. Each finding spans two lines \u2014 a `path:line:column` location (which terminals such as VS\n * Code render as a clickable link that jumps to the declaration) followed by the suggested change and\n * its reason \u2014 separated from the next finding by a blank line.\n *\n * @param findings - The findings to format.\n * @param options - The {@link FormatOverExposureFindingsOptions}.\n * @returns The report text. Empty-finding input yields a single \"no findings\" line.\n */\nexport function formatOverExposureFindings(findings: readonly OverExposureFinding[], options?: FormatOverExposureFindingsOptions): string {\n  if (findings.length === 0) {\n    return 'No over-exposed declarations found.\\n';\n  }\n\n  const baseFolder = options?.baseFolder === undefined ? undefined : toCanonical(options.baseFolder);\n\n  const byFile = new Map<string, OverExposureFinding[]>();\n  for (const finding of findings) {\n    const list = byFile.get(finding.filePath) ?? [];\n    list.push(finding);\n    byFile.set(finding.filePath, list);\n  }\n\n  const lines: string[] = [];\n  for (const [filePath, list] of byFile) {\n    const displayPath = toDisplayPath(filePath, baseFolder);\n    for (const finding of [...list].sort((a, b) => a.line - b.line)) {\n      const location = `${displayPath}:${String(finding.line)}:${String(finding.column)}`;\n      const change = `${finding.currentExposure} ${finding.name} -> ${finding.suggestedExposure}`;\n      lines.push(location, `${change} -- ${describeReason(finding)}`, '');\n    }\n  }\n  lines.push(`${String(findings.length)} finding(s).`);\n  return `${lines.join('\\n')}\\n`;\n}\n\nfunction analyzeExport(node: Node, context: AnalysisContext): void {\n  const sourceFile = node.getSourceFile();\n  if (node.parent !== sourceFile || !getModifierKinds(node).has(SyntaxKind.ExportKeyword)) {\n    return;\n  }\n\n  const declFilePath = toCanonical(sourceFile.fileName);\n  for (const nameNode of getExportedNameNodes(node)) {\n    const references = collectReferences(context.languageService.findReferences(sourceFile.fileName, nameNode.getStart()))\n      .filter((reference) => !isDeclarationItself(reference, nameNode));\n    const otherFileReferences = references.filter((reference) => toCanonical(reference.fileName) !== declFilePath);\n\n    if (otherFileReferences.length === 0) {\n      context.findings.push(buildFinding(node, nameNode, 'export', 'file-local', { hasNoReferences: references.length === 0, isForcedByTestOnly: false }));\n      continue;\n    }\n\n    const nonTestReferences = otherFileReferences.filter((reference) => !isTestFile(toCanonical(reference.fileName)));\n    if (nonTestReferences.length === 0) {\n      context.findings.push(buildFinding(node, nameNode, 'export', 'file-local', { hasNoReferences: false, isForcedByTestOnly: true }));\n    }\n  }\n}\n\nfunction analyzeMember(node: Node, context: AnalysisContext): void {\n  const nameNode = getMemberNameNode(node);\n  if (!nameNode || !isClassLike(node.parent)) {\n    return;\n  }\n  const declaringClass = node.parent;\n\n  const modifierKinds = getModifierKinds(node);\n  if (modifierKinds.has(SyntaxKind.StaticKeyword) || modifierKinds.has(SyntaxKind.OverrideKeyword) || LIFECYCLE_ALLOWLIST.has(nameNode.getText())) {\n    return;\n  }\n\n  const currentExposure = getCurrentMemberExposure(modifierKinds);\n  if (currentExposure === 'private') {\n    return;\n  }\n\n  const sourceFile = node.getSourceFile();\n  const references = collectReferences(context.languageService.findReferences(sourceFile.fileName, nameNode.getStart()))\n    .filter((reference) => !isDeclarationItself(reference, nameNode));\n  const nonTestReferences = references.filter((reference) => !isTestFile(toCanonical(reference.fileName)));\n\n  const neededForSrc = computeNeededExposure(nonTestReferences, declaringClass, context);\n  const neededWithTests = computeNeededExposure(references, declaringClass, context);\n\n  if (neededForSrc === 'public') {\n    return;\n  }\n\n  if (rankExposure(neededForSrc) >= rankExposure(currentExposure)) {\n    return;\n  }\n\n  context.findings.push(buildFinding(node, nameNode, currentExposure, neededForSrc, {\n    hasNoReferences: references.length === 0,\n    isForcedByTestOnly: rankExposure(neededWithTests) > rankExposure(neededForSrc)\n  }));\n}\n\nfunction buildFinding(\n  node: Node,\n  nameNode: Node,\n  currentExposure: CurrentExposure,\n  suggestedExposure: SuggestedExposure,\n  flags: FindingFlags\n): OverExposureFinding {\n  const sourceFile = node.getSourceFile();\n  const { character, line } = sourceFile.getLineAndCharacterOfPosition(nameNode.getStart());\n  return {\n    column: character + 1,\n    currentExposure,\n    filePath: toCanonical(sourceFile.fileName),\n    hasNoReferences: flags.hasNoReferences,\n    isForcedByTestOnly: flags.isForcedByTestOnly,\n    isMember: currentExposure !== 'export',\n    line: line + 1,\n    name: nameNode.getText(),\n    suggestedExposure\n  };\n}\n\nfunction collectReferences(referencedSymbols: ReferencedSymbol[] | undefined): ReferenceLocation[] {\n  const references: ReferenceLocation[] = [];\n  for (const referencedSymbol of referencedSymbols ?? []) {\n    for (const reference of referencedSymbol.references) {\n      references.push({ fileName: reference.fileName, start: reference.textSpan.start });\n    }\n  }\n  return references;\n}\n\nfunction computeNeededExposure(\n  references: readonly ReferenceLocation[],\n  declaringClass: ClassLikeDeclaration,\n  context: AnalysisContext\n): MemberExposure {\n  if (references.length === 0) {\n    return 'private';\n  }\n\n  let needed: MemberExposure = 'private';\n  for (const reference of references) {\n    const referenceClass = getClassAtPosition(context.program, reference.fileName, reference.start);\n    if (referenceClass === declaringClass) {\n      continue;\n    }\n    if (referenceClass && isDerivedFrom(referenceClass, declaringClass, context.checker)) {\n      needed = 'protected';\n      continue;\n    }\n    return 'public';\n  }\n  return needed;\n}\n\nfunction describeReason(finding: OverExposureFinding): string {\n  const base = `referenced only ${SCOPE_DESCRIPTION[finding.suggestedExposure]}`;\n  if (finding.isForcedByTestOnly) {\n    return `${base} (exposed only for tests)`;\n  }\n  if (finding.hasNoReferences) {\n    return `${base} (no references at all)`;\n  }\n  return base;\n}\n\nfunction findNodeAtPosition(node: Node, position: number): Node | undefined {\n  if (position < node.getStart() || position >= node.getEnd()) {\n    return undefined;\n  }\n  let result: Node = node;\n  node.forEachChild((child) => {\n    const found = findNodeAtPosition(child, position);\n    if (found) {\n      result = found;\n    }\n  });\n  return result;\n}\n\nfunction getClassAtPosition(program: Program, fileName: string, position: number): ClassLikeDeclaration | undefined {\n  const sourceFile = program.getSourceFile(fileName);\n  assertNonNullable(sourceFile, `Source file not found in program: ${fileName}`);\n  const node = findNodeAtPosition(sourceFile, position);\n  assertNonNullable(node, `No node found at position ${String(position)} in ${fileName}`);\n  return getEnclosingClass(node);\n}\n\nfunction getCurrentMemberExposure(modifierKinds: ReadonlySet<SyntaxKind>): MemberExposure {\n  if (modifierKinds.has(SyntaxKind.PrivateKeyword)) {\n    return 'private';\n  }\n  if (modifierKinds.has(SyntaxKind.ProtectedKeyword)) {\n    return 'protected';\n  }\n  return 'public';\n}\n\nfunction getEnclosingClass(node: Node): ClassLikeDeclaration | undefined {\n  let current: Node = node;\n  while (!isSourceFile(current)) {\n    if (isClassLike(current)) {\n      return current;\n    }\n    current = current.parent;\n  }\n  return undefined;\n}\n\nfunction getExportedNameNodes(node: Node): Node[] {\n  if (isFunctionDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isTypeAliasDeclaration(node) || isEnumDeclaration(node)) {\n    return node.name ? [node.name] : [];\n  }\n  if (isVariableStatement(node)) {\n    return node.declarationList.declarations.map((declaration) => declaration.name).filter(isIdentifier);\n  }\n  return [];\n}\n\nfunction getMemberNameNode(node: Node): Node | undefined {\n  if (isMethodDeclaration(node) || isPropertyDeclaration(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) {\n    return node.name;\n  }\n  return undefined;\n}\n\nfunction getModifierKinds(node: Node): ReadonlySet<SyntaxKind> {\n  const kinds = new Set<SyntaxKind>();\n  if (canHaveModifiers(node)) {\n    for (const modifier of getModifiers(node) ?? []) {\n      kinds.add(modifier.kind);\n    }\n  }\n  return kinds;\n}\n\nfunction isDeclarationItself(reference: ReferenceLocation, nameNode: Node): boolean {\n  return toCanonical(reference.fileName) === toCanonical(nameNode.getSourceFile().fileName) && reference.start === nameNode.getStart();\n}\n\nfunction isDerivedFrom(derived: ClassLikeDeclaration, base: ClassLikeDeclaration, checker: TypeChecker): boolean {\n  const baseSymbol = base.name ? checker.getSymbolAtLocation(base.name) : undefined;\n  if (!baseSymbol) {\n    return false;\n  }\n\n  for (const clause of derived.heritageClauses ?? []) {\n    if (clause.token !== SyntaxKind.ExtendsKeyword) {\n      continue;\n    }\n    for (const typeExpression of clause.types) {\n      const symbol = checker.getTypeAtLocation(typeExpression.expression).getSymbol();\n      if (symbol === baseSymbol) {\n        return true;\n      }\n      for (const declaration of symbol?.declarations ?? []) {\n        if (isClassLike(declaration) && isDerivedFrom(declaration, base, checker)) {\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nfunction isOwnSourceFile(filePath: string, srcFolder: string): boolean {\n  return filePath.startsWith(`${srcFolder}/`) && filePath.endsWith('.ts') && !filePath.endsWith('.d.ts');\n}\n\nfunction isTestFile(filePath: string): boolean {\n  return filePath.includes('.test.') || filePath.includes('.integration.');\n}\n\nfunction rankExposure(exposure: MemberExposure): number {\n  return MEMBER_EXPOSURE_ORDER.indexOf(exposure);\n}\n\nfunction toDisplayPath(filePath: string, baseFolder: string | undefined): string {\n  if (baseFolder !== undefined && filePath.startsWith(`${baseFolder}/`)) {\n    return filePath.slice(baseFolder.length + 1);\n  }\n  return filePath;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/script-utils/nano-staged-config.mjs

@@ -22,11 +22,19 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 const obsidianDevUtilsConfig = {
+  /*
+   * Lint everything except the `static/` consumer templates: ESLint globally ignores them, and they
+   * ship their own consumer-facing `eslint.config` that cannot resolve in-repo, so linting one by
+   * explicit path crashes config loading. The `!(static)` negation drops any path that begins with
+   * `static`. Formatting and spellchecking still cover `static/` via the entries above and below.
+   */
+  "!(static)*.{ts,tsx,mts}": [
+    "npm run lint:fix --"
+  ],
   "*": [
     "npm run spellcheck --"
   ],
   "*.{ts,tsx,mts}": [
-    "npm run lint:fix --",
     "npm run format --"
   ],
   "*.md": [
@@ -36,4 +44,4 @@ const obsidianDevUtilsConfig = {
 export {
   obsidianDevUtilsConfig
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9uYW5vLXN0YWdlZC1jb25maWcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBTaGFyZWQgbmFuby1zdGFnZWQgY29uZmlndXJhdGlvbiBmb3IgcHJlLWNvbW1pdCBob29rcy5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gRGVjbGFyYXRpdmUgbmFuby1zdGFnZWQgY29uZmlndXJhdGlvbjsgY29ycmVjdG5lc3MgaXMgdmVyaWZpZWQgYnkgcnVubmluZyBuYW5vLXN0YWdlZCwgbm90IHVuaXQgdGVzdHMuICovXG5cbi8qKlxuICogTmFuby1zdGFnZWQgY29uZmlndXJhdGlvbiB0aGF0IHJ1bnMgZmlsZS1iYXNlZCBsaW50LCBmb3JtYXQsIGFuZCBzcGVsbGNoZWNrIG9uIHN0YWdlZCBmaWxlcy5cbiAqXG4gKiBPbmx5IGluY2x1ZGVzIHRvb2xzIHRoYXQgY2FuIG9wZXJhdGUgb24gaW5kaXZpZHVhbCBmaWxlcy4gV2hvbGUtcHJvamVjdCBjaGVja3NcbiAqIChUeXBlU2NyaXB0IGNvbXBpbGF0aW9uLCB1bml0IHRlc3RzKSBhcmUgbGVmdCB0byBDSS5cbiAqXG4gKiBDb21tYW5kcyB1c2UgYG5wbSBydW4gLi4uIC0tYCBzbyBuYW5vLXN0YWdlZCBmaWxlIHBhdGhzIGFyZSBmb3J3YXJkZWQgYXMgQ0xJIGFyZ3VtZW50cy5cbiAqL1xuZXhwb3J0IGNvbnN0IG9ic2lkaWFuRGV2VXRpbHNDb25maWc6IFJlY29yZDxzdHJpbmcsIHN0cmluZ1tdPiA9IHtcbiAgJyonOiBbXG4gICAgJ25wbSBydW4gc3BlbGxjaGVjayAtLSdcbiAgXSxcbiAgJyoue3RzLHRzeCxtdHN9JzogW1xuICAgICducG0gcnVuIGxpbnQ6Zml4IC0tJyxcbiAgICAnbnBtIHJ1biBmb3JtYXQgLS0nXG4gIF0sXG4gICcqLm1kJzogW1xuICAgICducG0gcnVuIGxpbnQ6bWQ6Zml4IC0tJ1xuICBdXG59O1xuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFnQk8sTUFBTSx5QkFBbUQ7QUFBQSxFQUM5RCxLQUFLO0FBQUEsSUFDSDtBQUFBLEVBQ0Y7QUFBQSxFQUNBLGtCQUFrQjtBQUFBLElBQ2hCO0FBQUEsSUFDQTtBQUFBLEVBQ0Y7QUFBQSxFQUNBLFFBQVE7QUFBQSxJQUNOO0FBQUEsRUFDRjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/scripts/linters/over-exposure/find-overexposed.ts

@@ -0,0 +1,12 @@
+import process from 'node:process';
+
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+import {
+  findOverExposure,
+  formatOverExposureFindings
+} from 'obsidian-dev-utils/script-utils/linters/over-exposure';
+
+await wrapCliTask(() => {
+  const findings = findOverExposure({ projectFolder: process.cwd() });
+  process.stdout.write(formatOverExposureFindings(findings, { baseFolder: process.cwd() }));
+});

package/obsidian/Components/case-insensitive-file-index-component/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../dist/lib/cjs/obsidian/components/case-insensitive-file-index-component.cjs",
+  "module": "../../../dist/lib/esm/obsidian/components/case-insensitive-file-index-component.mjs",
+  "type": "module",
+  "types": "../../../dist/lib/cjs/obsidian/components/case-insensitive-file-index-component.d.cts"
+}

package/obsidian/Components/embed-extensions-component/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../dist/lib/cjs/obsidian/components/embed-extensions-component.cjs",
+  "module": "../../../dist/lib/esm/obsidian/components/embed-extensions-component.mjs",
+  "type": "module",
+  "types": "../../../dist/lib/cjs/obsidian/components/embed-extensions-component.d.cts"
+}

package/obsidian/case-insensitive-file-index/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/obsidian/case-insensitive-file-index.cjs",
+  "module": "../../dist/lib/esm/obsidian/case-insensitive-file-index.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/obsidian/case-insensitive-file-index.d.cts"
+}

package/obsidian/view-registrar/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/obsidian/view-registrar.cjs",
+  "module": "../../dist/lib/esm/obsidian/view-registrar.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/obsidian/view-registrar.d.cts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "76.1.0",
+  "version": "77.1.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development.",
   "keywords": [
     "obsidian"
@@ -656,7 +656,7 @@
     "@eslint/config-helpers": "^0.6.0",
     "@eslint/js": "^10.0.1",
     "@lezer/common": "1.2.3",
-    "@obsidian-typings/obsidian-public-latest": "^6.15.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.18.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tsconfig/strictest": "^2.0.8",
     "@types/babel__core": "^7.20.5",
@@ -671,8 +671,8 @@
     "@types/react": "^19.2.17",
     "@types/semver": "^7.7.1",
     "@types/shell-quote": "^1.7.5",
-    "@typescript-eslint/eslint-plugin": "^8.61.1",
-    "@typescript-eslint/parser": "^8.61.1",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
     "commander": "^15.0.0",
     "compare-versions": "^6.1.1",
     "cspell": "^10.0.1",
@@ -684,13 +684,13 @@
     "esbuild-svelte": "^0.9.5",
     "eslint": "^10.5.0",
     "eslint-import-resolver-typescript": "^4.4.5",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^63.0.6",
+    "eslint-plugin-import-x": "^4.17.0",
+    "eslint-plugin-jsdoc": "^63.0.7",
     "eslint-plugin-no-unsanitized": "^4.1.5",
     "eslint-plugin-obsidianmd": "^0.3.0",
     "eslint-plugin-perfectionist": "^5.9.1",
     "eslint-plugin-tsdoc": "^0.5.2",
-    "globals": "^17.6.0",
+    "globals": "^17.7.0",
     "i18next": "^26.3.1",
     "jiti": "^2.7.0",
     "linkinator": "^7.6.1",
@@ -712,20 +712,20 @@
     "sass": "^1.101.0",
     "semver": "^7.8.5",
     "shell-quote": "^1.8.4",
-    "svelte-check": "^4.6.0",
+    "svelte-check": "^4.7.0",
     "svelte-preprocess": "^6.0.5",
     "type-fest": "^5.7.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.61.1",
+    "typescript-eslint": "^8.62.0",
     "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "^21.0.2",
-    "@commitlint/config-conventional": "^21.0.2",
-    "@commitlint/types": "^21.0.1",
+    "@commitlint/cli": "^21.1.0",
+    "@commitlint/config-conventional": "^21.1.0",
+    "@commitlint/types": "^21.1.0",
     "@jest/globals": "^30.4.1",
     "@total-typescript/ts-reset": "^0.6.1",
-    "@typescript-eslint/rule-tester": "^8.61.1",
+    "@typescript-eslint/rule-tester": "^8.62.0",
     "@vitest/coverage-v8": "^4.1.9",
     "@vitest/runner": "^4.1.9",
     "better-typescript-lib": "^2.12.0",
@@ -736,8 +736,8 @@
     "jsdom": "^29.1.1",
     "moment": "^2.30.1",
     "nano-staged": "^1.0.2",
-    "obsidian-integration-testing": "^4.2.6",
-    "obsidian-test-mocks": "^3.1.1",
+    "obsidian-integration-testing": "^4.4.0",
+    "obsidian-test-mocks": "^3.3.0",
     "ts-declaration-location": "^1.0.7",
     "vitest": "^4.1.9",
     "yaml": "^2.9.0"

package/script-utils/linters/over-exposure/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../dist/lib/cjs/script-utils/linters/over-exposure.cjs",
+  "module": "../../../dist/lib/esm/script-utils/linters/over-exposure.mjs",
+  "type": "module",
+  "types": "../../../dist/lib/cjs/script-utils/linters/over-exposure.d.cts"
+}