@mnaoumov/typescript-dev-toolkit 4.0.0 → 5.1.0

package/dist/lib/esm/linters/eslint-rules/no-keyword-identifiers.mjs

@@ -0,0 +1,120 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+const RESTRICTED_NAMES = /* @__PURE__ */ new Set([
+  "arguments",
+  "bigint",
+  "boolean",
+  "event",
+  "function",
+  "module",
+  "number",
+  "object",
+  "string",
+  "symbol",
+  "undefined"
+]);
+const noKeywordIdentifiers = {
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      "Program:exit"() {
+        const scopes = sourceCode.scopeManager.scopes;
+        const reported = /* @__PURE__ */ new Set();
+        for (const scope of scopes) {
+          for (const variable of scope.variables) {
+            if (!RESTRICTED_NAMES.has(variable.name)) {
+              continue;
+            }
+            const replacement = `$${variable.name}`;
+            const nodes = [.../* @__PURE__ */ new Set([...variable.identifiers, ...variable.references.map((reference) => reference.identifier)])];
+            const canRename = variable.defs.every((definition) => definition.type !== "ClassName") && scopes.every(
+              (candidate) => candidate.variables.every((binding) => binding.name !== replacement) && candidate.through.every((reference) => reference.identifier.name !== replacement)
+            ) && nodes.every(
+              (node) => sourceCode.getAncestors(node).every(
+                (ancestor) => ![
+                  "ExportDefaultDeclaration",
+                  "ExportNamedDeclaration",
+                  "ExportSpecifier",
+                  "ImportSpecifier",
+                  "Property",
+                  "TSParameterProperty"
+                ].includes(ancestor.type)
+              )
+            );
+            for (const identifier of variable.identifiers) {
+              if (reported.has(identifier)) {
+                continue;
+              }
+              reported.add(identifier);
+              context.report({
+                data: { name: variable.name, replacement },
+                messageId: "restricted",
+                node: identifier,
+                suggest: canRename ? [{
+                  data: { replacement },
+                  fix: (fixer) => nodes.map((node) => {
+                    const token = sourceCode.getFirstToken(node);
+                    assertNonNullable(token, "A binding identifier always has a token");
+                    return fixer.replaceText(token, replacement);
+                  }),
+                  messageId: "rename"
+                }] : []
+              });
+            }
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: { description: "Require a $ prefix on bare keyword and colliding global binding names" },
+    hasSuggestions: true,
+    messages: {
+      rename: 'Rename this binding and its references to "{{ replacement }}".',
+      restricted: 'Rename "{{ name }}" to "{{ replacement }}". Preserve any public contract when renaming.'
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+export {
+  noKeywordIdentifiers
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saW50ZXJzL2VzbGludC1ydWxlcy9uby1rZXl3b3JkLWlkZW50aWZpZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBSZWplY3QgYmFyZSBrZXl3b3JkIGFuZCBjb2xsaWRpbmcgZ2xvYmFsIG5hbWVzIGluIGRlY2xhcmVkIGJpbmRpbmdzLlxuICovXG5pbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tICdlc2xpbnQnO1xuXG5pbXBvcnQgeyBhc3NlcnROb25OdWxsYWJsZSB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi90eXBlLWd1YXJkcyc7XG5cbmNvbnN0IFJFU1RSSUNURURfTkFNRVMgPSBuZXcgU2V0KFtcbiAgJ2FyZ3VtZW50cycsXG4gICdiaWdpbnQnLFxuICAnYm9vbGVhbicsXG4gICdldmVudCcsXG4gICdmdW5jdGlvbicsXG4gICdtb2R1bGUnLFxuICAnbnVtYmVyJyxcbiAgJ29iamVjdCcsXG4gICdzdHJpbmcnLFxuICAnc3ltYm9sJyxcbiAgJ3VuZGVmaW5lZCdcbl0pO1xuXG4vKipcbiAqIERpc2FsbG93cyBiYXJlIGtleXdvcmQgbmFtZXMsIHdpdGggY29uc2VydmF0aXZlLCBzY29wZS1hd2FyZSByZW5hbWUgc3VnZ2VzdGlvbnMgZm9yIGxvY2FsIGJpbmRpbmdzLlxuICovXG5leHBvcnQgY29uc3Qgbm9LZXl3b3JkSWRlbnRpZmllcnM6IFJ1bGUuUnVsZU1vZHVsZSA9IHtcbiAgY3JlYXRlKGNvbnRleHQpIHtcbiAgICBjb25zdCBzb3VyY2VDb2RlID0gY29udGV4dC5zb3VyY2VDb2RlO1xuICAgIHJldHVybiB7XG4gICAgICAnUHJvZ3JhbTpleGl0JygpOiB2b2lkIHtcbiAgICAgICAgY29uc3Qgc2NvcGVzID0gc291cmNlQ29kZS5zY29wZU1hbmFnZXIuc2NvcGVzO1xuICAgICAgICBjb25zdCByZXBvcnRlZCA9IG5ldyBTZXQ8dW5rbm93bj4oKTtcbiAgICAgICAgZm9yIChjb25zdCBzY29wZSBvZiBzY29wZXMpIHtcbiAgICAgICAgICBmb3IgKGNvbnN0IHZhcmlhYmxlIG9mIHNjb3BlLnZhcmlhYmxlcykge1xuICAgICAgICAgICAgaWYgKCFSRVNUUklDVEVEX05BTUVTLmhhcyh2YXJpYWJsZS5uYW1lKSkge1xuICAgICAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGNvbnN0IHJlcGxhY2VtZW50ID0gYCQke3ZhcmlhYmxlLm5hbWV9YDtcbiAgICAgICAgICAgIGNvbnN0IG5vZGVzID0gWy4uLm5ldyBTZXQoWy4uLnZhcmlhYmxlLmlkZW50aWZpZXJzLCAuLi52YXJpYWJsZS5yZWZlcmVuY2VzLm1hcCgocmVmZXJlbmNlKSA9PiByZWZlcmVuY2UuaWRlbnRpZmllcildKV07XG4gICAgICAgICAgICBjb25zdCBjYW5SZW5hbWUgPSB2YXJpYWJsZS5kZWZzLmV2ZXJ5KChkZWZpbml0aW9uKSA9PiBkZWZpbml0aW9uLnR5cGUgIT09ICdDbGFzc05hbWUnKVxuICAgICAgICAgICAgICAmJiBzY29wZXMuZXZlcnkoKGNhbmRpZGF0ZSkgPT5cbiAgICAgICAgICAgICAgICBjYW5kaWRhdGUudmFyaWFibGVzLmV2ZXJ5KChiaW5kaW5nKSA9PiBiaW5kaW5nLm5hbWUgIT09IHJlcGxhY2VtZW50KVxuICAgICAgICAgICAgICAgICYmIGNhbmRpZGF0ZS50aHJvdWdoLmV2ZXJ5KChyZWZlcmVuY2UpID0+IHJlZmVyZW5jZS5pZGVudGlmaWVyLm5hbWUgIT09IHJlcGxhY2VtZW50KVxuICAgICAgICAgICAgICApXG4gICAgICAgICAgICAgICYmIG5vZGVzLmV2ZXJ5KChub2RlKSA9PlxuICAgICAgICAgICAgICAgIHNvdXJjZUNvZGUuZ2V0QW5jZXN0b3JzKG5vZGUpLmV2ZXJ5KChhbmNlc3RvcikgPT5cbiAgICAgICAgICAgICAgICAgICFbXG4gICAgICAgICAgICAgICAgICAgICdFeHBvcnREZWZhdWx0RGVjbGFyYXRpb24nLFxuICAgICAgICAgICAgICAgICAgICAnRXhwb3J0TmFtZWREZWNsYXJhdGlvbicsXG4gICAgICAgICAgICAgICAgICAgICdFeHBvcnRTcGVjaWZpZXInLFxuICAgICAgICAgICAgICAgICAgICAnSW1wb3J0U3BlY2lmaWVyJyxcbiAgICAgICAgICAgICAgICAgICAgJ1Byb3BlcnR5JyxcbiAgICAgICAgICAgICAgICAgICAgJ1RTUGFyYW1ldGVyUHJvcGVydHknXG4gICAgICAgICAgICAgICAgICBdLmluY2x1ZGVzKGFuY2VzdG9yLnR5cGUpXG4gICAgICAgICAgICAgICAgKVxuICAgICAgICAgICAgICApO1xuICAgICAgICAgICAgZm9yIChjb25zdCBpZGVudGlmaWVyIG9mIHZhcmlhYmxlLmlkZW50aWZpZXJzKSB7XG4gICAgICAgICAgICAgIGlmIChyZXBvcnRlZC5oYXMoaWRlbnRpZmllcikpIHtcbiAgICAgICAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICByZXBvcnRlZC5hZGQoaWRlbnRpZmllcik7XG4gICAgICAgICAgICAgIGNvbnRleHQucmVwb3J0KHtcbiAgICAgICAgICAgICAgICBkYXRhOiB7IG5hbWU6IHZhcmlhYmxlLm5hbWUsIHJlcGxhY2VtZW50IH0sXG4gICAgICAgICAgICAgICAgbWVzc2FnZUlkOiAncmVzdHJpY3RlZCcsXG4gICAgICAgICAgICAgICAgbm9kZTogaWRlbnRpZmllcixcbiAgICAgICAgICAgICAgICBzdWdnZXN0OiBjYW5SZW5hbWVcbiAgICAgICAgICAgICAgICAgID8gW3tcbiAgICAgICAgICAgICAgICAgICAgZGF0YTogeyByZXBsYWNlbWVudCB9LFxuICAgICAgICAgICAgICAgICAgICBmaXg6IChmaXhlcik6IFJ1bGUuRml4W10gPT5cbiAgICAgICAgICAgICAgICAgICAgICBub2Rlcy5tYXAoKG5vZGUpID0+IHtcbiAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHRva2VuID0gc291cmNlQ29kZS5nZXRGaXJzdFRva2VuKG5vZGUpO1xuICAgICAgICAgICAgICAgICAgICAgICAgYXNzZXJ0Tm9uTnVsbGFibGUodG9rZW4sICdBIGJpbmRpbmcgaWRlbnRpZmllciBhbHdheXMgaGFzIGEgdG9rZW4nKTtcbiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBmaXhlci5yZXBsYWNlVGV4dCh0b2tlbiwgcmVwbGFjZW1lbnQpO1xuICAgICAgICAgICAgICAgICAgICAgIH0pLFxuICAgICAgICAgICAgICAgICAgICBtZXNzYWdlSWQ6ICdyZW5hbWUnXG4gICAgICAgICAgICAgICAgICB9XVxuICAgICAgICAgICAgICAgICAgOiBbXVxuICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9O1xuICB9LFxuICBtZXRhOiB7XG4gICAgZG9jczogeyBkZXNjcmlwdGlvbjogJ1JlcXVpcmUgYSAkIHByZWZpeCBvbiBiYXJlIGtleXdvcmQgYW5kIGNvbGxpZGluZyBnbG9iYWwgYmluZGluZyBuYW1lcycgfSxcbiAgICBoYXNTdWdnZXN0aW9uczogdHJ1ZSxcbiAgICBtZXNzYWdlczoge1xuICAgICAgcmVuYW1lOiAnUmVuYW1lIHRoaXMgYmluZGluZyBhbmQgaXRzIHJlZmVyZW5jZXMgdG8gXCJ7eyByZXBsYWNlbWVudCB9fVwiLicsXG4gICAgICByZXN0cmljdGVkOiAnUmVuYW1lIFwie3sgbmFtZSB9fVwiIHRvIFwie3sgcmVwbGFjZW1lbnQgfX1cIi4gUHJlc2VydmUgYW55IHB1YmxpYyBjb250cmFjdCB3aGVuIHJlbmFtaW5nLidcbiAgICB9LFxuICAgIHNjaGVtYTogW10sXG4gICAgdHlwZTogJ3N1Z2dlc3Rpb24nXG4gIH1cbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBT0EsU0FBUyx5QkFBeUI7QUFFbEMsTUFBTSxtQkFBbUIsb0JBQUksSUFBSTtBQUFBLEVBQy9CO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUNGLENBQUM7QUFLTSxNQUFNLHVCQUF3QztBQUFBLEVBQ25ELE9BQU8sU0FBUztBQUNkLFVBQU0sYUFBYSxRQUFRO0FBQzNCLFdBQU87QUFBQSxNQUNMLGlCQUF1QjtBQUNyQixjQUFNLFNBQVMsV0FBVyxhQUFhO0FBQ3ZDLGNBQU0sV0FBVyxvQkFBSSxJQUFhO0FBQ2xDLG1CQUFXLFNBQVMsUUFBUTtBQUMxQixxQkFBVyxZQUFZLE1BQU0sV0FBVztBQUN0QyxnQkFBSSxDQUFDLGlCQUFpQixJQUFJLFNBQVMsSUFBSSxHQUFHO0FBQ3hDO0FBQUEsWUFDRjtBQUNBLGtCQUFNLGNBQWMsSUFBSSxTQUFTLElBQUk7QUFDckMsa0JBQU0sUUFBUSxDQUFDLEdBQUcsb0JBQUksSUFBSSxDQUFDLEdBQUcsU0FBUyxhQUFhLEdBQUcsU0FBUyxXQUFXLElBQUksQ0FBQyxjQUFjLFVBQVUsVUFBVSxDQUFDLENBQUMsQ0FBQztBQUNySCxrQkFBTSxZQUFZLFNBQVMsS0FBSyxNQUFNLENBQUMsZUFBZSxXQUFXLFNBQVMsV0FBVyxLQUNoRixPQUFPO0FBQUEsY0FBTSxDQUFDLGNBQ2YsVUFBVSxVQUFVLE1BQU0sQ0FBQyxZQUFZLFFBQVEsU0FBUyxXQUFXLEtBQ2hFLFVBQVUsUUFBUSxNQUFNLENBQUMsY0FBYyxVQUFVLFdBQVcsU0FBUyxXQUFXO0FBQUEsWUFDckYsS0FDRyxNQUFNO0FBQUEsY0FBTSxDQUFDLFNBQ2QsV0FBVyxhQUFhLElBQUksRUFBRTtBQUFBLGdCQUFNLENBQUMsYUFDbkMsQ0FBQztBQUFBLGtCQUNDO0FBQUEsa0JBQ0E7QUFBQSxrQkFDQTtBQUFBLGtCQUNBO0FBQUEsa0JBQ0E7QUFBQSxrQkFDQTtBQUFBLGdCQUNGLEVBQUUsU0FBUyxTQUFTLElBQUk7QUFBQSxjQUMxQjtBQUFBLFlBQ0Y7QUFDRix1QkFBVyxjQUFjLFNBQVMsYUFBYTtBQUM3QyxrQkFBSSxTQUFTLElBQUksVUFBVSxHQUFHO0FBQzVCO0FBQUEsY0FDRjtBQUNBLHVCQUFTLElBQUksVUFBVTtBQUN2QixzQkFBUSxPQUFPO0FBQUEsZ0JBQ2IsTUFBTSxFQUFFLE1BQU0sU0FBUyxNQUFNLFlBQVk7QUFBQSxnQkFDekMsV0FBVztBQUFBLGdCQUNYLE1BQU07QUFBQSxnQkFDTixTQUFTLFlBQ0wsQ0FBQztBQUFBLGtCQUNELE1BQU0sRUFBRSxZQUFZO0FBQUEsa0JBQ3BCLEtBQUssQ0FBQyxVQUNKLE1BQU0sSUFBSSxDQUFDLFNBQVM7QUFDbEIsMEJBQU0sUUFBUSxXQUFXLGNBQWMsSUFBSTtBQUMzQyxzQ0FBa0IsT0FBTyx5Q0FBeUM7QUFDbEUsMkJBQU8sTUFBTSxZQUFZLE9BQU8sV0FBVztBQUFBLGtCQUM3QyxDQUFDO0FBQUEsa0JBQ0gsV0FBVztBQUFBLGdCQUNiLENBQUMsSUFDQyxDQUFDO0FBQUEsY0FDUCxDQUFDO0FBQUEsWUFDSDtBQUFBLFVBQ0Y7QUFBQSxRQUNGO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQUEsRUFDQSxNQUFNO0FBQUEsSUFDSixNQUFNLEVBQUUsYUFBYSx3RUFBd0U7QUFBQSxJQUM3RixnQkFBZ0I7QUFBQSxJQUNoQixVQUFVO0FBQUEsTUFDUixRQUFRO0FBQUEsTUFDUixZQUFZO0FBQUEsSUFDZDtBQUFBLElBQ0EsUUFBUSxDQUFDO0FBQUEsSUFDVCxNQUFNO0FBQUEsRUFDUjtBQUNGOyIsIm5hbWVzIjpbXX0=

package/dist/lib/esm/linters/eslint-rules/no-unresolved-jsdoc-link.mjs

@@ -186,9 +186,9 @@ function findModuleByPathSuffix(program, checker, modulePath) {
 function flattenName(name) {
   return isIdentifier(name) ? [name.text] : [...flattenName(name.left), name.right.text];
 }
-function getMember(checker, symbol, memberName) {
+function getMember(checker, $symbol, memberName) {
   const escapedName = escapeLeadingUnderscores(memberName);
-  const target = resolveAlias(checker, symbol);
+  const target = resolveAlias(checker, $symbol);
   const moduleExport = (target.flags & SymbolFlags.Module) === 0 ? void 0 : checker.tryGetMemberInModuleExports(memberName, target);
   return moduleExport ?? target.exports?.get(escapedName) ?? target.members?.get(escapedName) ?? checker.getPropertyOfType(checker.getDeclaredTypeOfSymbol(target), memberName) ?? checker.getPropertyOfType(checker.getTypeOfSymbol(target), memberName);
 }
@@ -248,8 +248,8 @@ function isResolvedName(params) {
   const roots = [...localRoots, ...index.exportsByName.get(rootName) ?? [], findModule(program, checker, rootName, containingFileName)];
   return roots.some((root) => !!resolveMemberPath(checker, root, memberNames));
 }
-function resolveAlias(checker, symbol) {
-  return (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);
+function resolveAlias(checker, $symbol) {
+  return ($symbol.flags & SymbolFlags.Alias) === 0 ? $symbol : checker.getAliasedSymbol($symbol);
 }
 function resolveMemberPath(checker, root, memberNames) {
   let current = root;
@@ -265,4 +265,4 @@ export {
   MESSAGE_ID,
   noUnresolvedJsdocLink
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/no-unresolved-jsdoc-link.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: no-unresolved-jsdoc-link\n *\n * Reports a JSDoc `link`, `linkcode` or `linkplain` inline tag whose target no longer resolves to a symbol.\n *\n * A rename leaves `{@link OldName}` behind and nothing else reports it: `jsdoc/no-undefined-types` does not resolve\n * link targets, TSDoc checks only the tag syntax, and `tsc` parses JSDoc links without ever diagnosing them. So a dead\n * link survives until somebody happens to click it.\n *\n * A target resolves when any of these finds it, tried in order:\n *\n * 1. The type checker, at the comment's own location, exactly as editor go-to-definition does — so everything in\n *    scope there resolves: type parameters, parameters, imports, and the DOM / ES globals.\n * 2. A declaration anywhere in the same file — a function nested in another, a private method — which is out of\n *    scope at a `*Params` interface naming it, yet is exactly what a rename of it would break.\n * 3. The exports of any module in the program, by name. A comment routinely names a type its file never imports (an\n *    integration test naming the class it drives through `evalInObsidian`, a remark naming an Obsidian API), and the\n *    API docs generator resolves such a name library-wide too. This keeps the rule about DEAD links rather than\n *    about imports: a renamed or removed declaration is exported by no module, so it is still reported.\n * 4. A module named by its specifier or its path, in both TSDoc forms: `obsidian#Events#on` (the package as the first\n *    segment) and `error!errorToString` / `obsidian/components/plugin-gate-component!PluginConflictSeverity.Warn`\n *    (a module path, ending with `!`) — plus TypeScript's own `import('./module.ts').Member`. A path matches any\n *    source file in the program whose path ends with it.\n *\n * After the first segment, each further `.` / `#` segment is looked up as a member: a namespace or module export, a\n * static or instance member, or a property of the previous member's type — so `App.vault.adapter` resolves.\n *\n * A link that is not a code reference is skipped: a URL (`{@link https://example.com}`) and a JSDoc namepath\n * (`{@link module:foo}`) both parse as a name followed by text starting with `:`, and a link with no name has\n * nothing to resolve.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type {\n  ClassDeclaration,\n  EntityName,\n  EnumDeclaration,\n  FunctionDeclaration,\n  GetAccessorDeclaration,\n  Identifier,\n  InterfaceDeclaration,\n  JSDocLink,\n  JSDocLinkCode,\n  JSDocLinkPlain,\n  JSDocMemberName,\n  MethodDeclaration,\n  MethodSignature,\n  ModuleDeclaration,\n  Node,\n  Program,\n  PropertyDeclaration,\n  PropertySignature,\n  SetAccessorDeclaration,\n  Symbol as TsSymbol,\n  TypeAliasDeclaration,\n  TypeChecker,\n  VariableDeclaration\n} from 'typescript';\n\nimport {\n  escapeLeadingUnderscores,\n  forEachChild,\n  getJSDocCommentsAndTags,\n  isClassDeclaration,\n  isEnumDeclaration,\n  isFunctionDeclaration,\n  isGetAccessorDeclaration,\n  isIdentifier,\n  isInterfaceDeclaration,\n  isJSDocLink,\n  isJSDocLinkCode,\n  isJSDocLinkPlain,\n  isJSDocMemberName,\n  isMethodDeclaration,\n  isMethodSignature,\n  isModuleDeclaration,\n  isPropertyDeclaration,\n  isPropertySignature,\n  isSetAccessorDeclaration,\n  isTypeAliasDeclaration,\n  isVariableDeclaration,\n  resolveModuleName,\n  SymbolFlags,\n  sys\n} from 'typescript';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\n/**\n * Message ID reported when a JSDoc link target does not resolve to a symbol.\n */\nexport const MESSAGE_ID = 'noUnresolvedJsdocLink';\n\ninterface IsResolvedNameParams {\n  readonly checker: TypeChecker;\n  readonly containingFileName: string;\n  readonly localDeclarationNamesByName: ReadonlyMap<string, readonly Identifier[]>;\n  readonly name: EntityName | JSDocMemberName;\n  readonly program: Program;\n}\n\ntype JSDocLinkLike = JSDocLink | JSDocLinkCode | JSDocLinkPlain;\n\ntype LocalDeclaration =\n  | ClassDeclaration\n  | EnumDeclaration\n  | FunctionDeclaration\n  | GetAccessorDeclaration\n  | InterfaceDeclaration\n  | MethodDeclaration\n  | MethodSignature\n  | ModuleDeclaration\n  | PropertyDeclaration\n  | PropertySignature\n  | SetAccessorDeclaration\n  | TypeAliasDeclaration\n  | VariableDeclaration;\n\ntype ModulePathMatchGroups = Readonly<Record<'memberPath' | 'modulePath', string>>;\n\ninterface ProgramIndex {\n  readonly exportsByName: Map<string, TsSymbol[]>;\n  readonly modulesByPath: Map<string, TsSymbol>;\n}\n\nconst MODULE_PATH_REG_EXP = /^(?<modulePath>[^\\s!|}]*)!(?<memberPath>[\\w$.#]+)/;\nconst IMPORT_TYPE_REG_EXP = /^import\\(\\s*(?<quote>['\"])(?<modulePath>[^'\"]+)\\k<quote>\\s*\\)\\.(?<memberPath>[\\w$.#]+)/;\nconst RELATIVE_PATH_PREFIX_REG_EXP = /^(?:\\.\\.?\\/)+/;\nconst MEMBER_SEPARATOR_REG_EXP = /[.#]/;\nconst SOURCE_FILE_EXTENSION_REG_EXP = /(?:\\.d)?\\.[cm]?tsx?$/;\nconst INDEX_SUFFIX = '/index';\n\nconst programIndexCache = new WeakMap<Program, ProgramIndex>();\n\n/**\n * The ESLint rule that reports JSDoc links whose target does not resolve.\n */\nexport const noUnresolvedJsdocLink: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n\n    return {\n      Program(node): void {\n        const program = services.program;\n        const checker = program.getTypeChecker();\n        const tsSourceFile = services.esTreeNodeToTSNodeMap.get(toTSESTreeNode(node) as TSESTree.Program);\n\n        /*\n         * The same link is reachable more than once: a parameter returns its own `@param` tag, which its function's\n         * JSDoc block also contains. So deduplicate on the link itself rather than on the JSDoc node.\n         */\n        const links = new Set<JSDocLinkLike>();\n\n        /*\n         * A link may name a declaration further down the file, so the whole file is walked before any link is\n         * resolved.\n         */\n        const localDeclarationNamesByName = new Map<string, Identifier[]>();\n\n        function visitJsDocNode(jsDocNode: Node): void {\n          if (isJSDocLinkLike(jsDocNode)) {\n            links.add(jsDocNode);\n            return;\n          }\n          forEachChild(jsDocNode, visitJsDocNode);\n        }\n\n        function visitNode(tsNode: Node): void {\n          collectLocalDeclarationName(tsNode, localDeclarationNamesByName);\n          for (const jsDocNode of getJSDocCommentsAndTags(tsNode)) {\n            visitJsDocNode(jsDocNode);\n          }\n          forEachChild(tsNode, visitNode);\n        }\n\n        function reportIfUnresolved(link: JSDocLinkLike): void {\n          if (!link.name || link.text.startsWith(':')) {\n            return;\n          }\n\n          const nameText = link.name.getText();\n          const fullTarget = nameText + link.text;\n          const moduleMatch = IMPORT_TYPE_REG_EXP.exec(fullTarget) ?? MODULE_PATH_REG_EXP.exec(fullTarget);\n          let reportedName = nameText;\n          let isResolved: boolean;\n\n          if (moduleMatch?.groups) {\n            const { memberPath, modulePath } = moduleMatch.groups as ModulePathMatchGroups;\n            reportedName = moduleMatch[0];\n            const moduleSymbol = findModule(program, checker, modulePath, tsSourceFile.fileName);\n            isResolved = !!resolveMemberPath(checker, moduleSymbol, memberPath.split(MEMBER_SEPARATOR_REG_EXP));\n          } else {\n            isResolved = isResolvedName({\n              checker,\n              containingFileName: tsSourceFile.fileName,\n              localDeclarationNamesByName,\n              name: link.name,\n              program\n            });\n          }\n\n          if (isResolved) {\n            return;\n          }\n\n          context.report({\n            data: {\n              name: reportedName\n            },\n            loc: {\n              end: context.sourceCode.getLocFromIndex(link.name.getEnd()),\n              start: context.sourceCode.getLocFromIndex(link.name.getStart())\n            },\n            messageId: MESSAGE_ID\n          });\n        }\n\n        visitNode(tsSourceFile);\n        for (const link of links) {\n          reportIfUnresolved(link);\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow JSDoc link tags whose target does not resolve to a symbol'\n    },\n    messages: {\n      [MESSAGE_ID]: 'JSDoc link target `{{name}}` does not resolve. Was it renamed or removed?'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\nfunction collectLocalDeclarationName(node: Node, localDeclarationNamesByName: Map<string, Identifier[]>): void {\n  if (!isLocalDeclaration(node) || !node.name || !isIdentifier(node.name)) {\n    return;\n  }\n  const names = localDeclarationNamesByName.get(node.name.text) ?? [];\n  names.push(node.name);\n  localDeclarationNamesByName.set(node.name.text, names);\n}\n\nfunction findModule(program: Program, checker: TypeChecker, specifier: string, containingFileName: string): TsSymbol | undefined {\n  const ambientModule = getProgramIndex(program, checker).modulesByPath.get(specifier);\n  if (ambientModule) {\n    return ambientModule;\n  }\n\n  const resolvedFileName = resolveModuleName(specifier, containingFileName, program.getCompilerOptions(), sys).resolvedModule?.resolvedFileName;\n  const resolvedSourceFile = resolvedFileName === undefined ? undefined : program.getSourceFile(resolvedFileName);\n  const resolvedModule = resolvedSourceFile && checker.getSymbolAtLocation(resolvedSourceFile);\n  return resolvedModule ?? findModuleByPathSuffix(program, checker, specifier);\n}\n\nfunction findModuleByPathSuffix(program: Program, checker: TypeChecker, modulePath: string): TsSymbol | undefined {\n  const normalizedPath = modulePath.replace(RELATIVE_PATH_PREFIX_REG_EXP, '').replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n  const suffixes = [`/${normalizedPath}`, `/${normalizedPath}${INDEX_SUFFIX}`];\n  for (const sourceFile of program.getSourceFiles()) {\n    const pathWithoutExtension = sourceFile.fileName.replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n    if (suffixes.every((suffix) => !pathWithoutExtension.endsWith(suffix))) {\n      continue;\n    }\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      return moduleSymbol;\n    }\n  }\n  return undefined;\n}\n\nfunction flattenName(name: EntityName | JSDocMemberName): string[] {\n  return isIdentifier(name) ? [name.text] : [...flattenName(name.left), name.right.text];\n}\n\nfunction getMember(checker: TypeChecker, symbol: TsSymbol, memberName: string): TsSymbol | undefined {\n  const escapedName = escapeLeadingUnderscores(memberName);\n  const target = resolveAlias(checker, symbol);\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  const moduleExport = (target.flags & SymbolFlags.Module) === 0 ? undefined : checker.tryGetMemberInModuleExports(memberName, target);\n  return moduleExport\n    ?? target.exports?.get(escapedName)\n    ?? target.members?.get(escapedName)\n    ?? checker.getPropertyOfType(checker.getDeclaredTypeOfSymbol(target), memberName)\n    ?? checker.getPropertyOfType(checker.getTypeOfSymbol(target), memberName);\n}\n\nfunction getProgramIndex(program: Program, checker: TypeChecker): ProgramIndex {\n  let index = programIndexCache.get(program);\n  if (index) {\n    return index;\n  }\n\n  index = {\n    exportsByName: new Map<string, TsSymbol[]>(),\n    modulesByPath: new Map<string, TsSymbol>()\n  };\n\n  const moduleSymbols: TsSymbol[] = [];\n  for (const ambientModule of checker.getAmbientModules()) {\n    index.modulesByPath.set(ambientModule.name.replaceAll('\"', ''), ambientModule);\n    moduleSymbols.push(ambientModule);\n  }\n  for (const sourceFile of program.getSourceFiles()) {\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      moduleSymbols.push(moduleSymbol);\n    }\n  }\n\n  for (const moduleSymbol of moduleSymbols) {\n    for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {\n      const symbols = index.exportsByName.get(exportSymbol.name) ?? [];\n      symbols.push(exportSymbol);\n      index.exportsByName.set(exportSymbol.name, symbols);\n    }\n  }\n\n  programIndexCache.set(program, index);\n  return index;\n}\n\nfunction isJSDocLinkLike(node: Node): node is JSDocLinkLike {\n  return isJSDocLink(node) || isJSDocLinkCode(node) || isJSDocLinkPlain(node);\n}\n\nfunction isLocalDeclaration(node: Node): node is LocalDeclaration {\n  return isClassDeclaration(node)\n    || isEnumDeclaration(node)\n    || isFunctionDeclaration(node)\n    || isGetAccessorDeclaration(node)\n    || isInterfaceDeclaration(node)\n    || isMethodDeclaration(node)\n    || isMethodSignature(node)\n    || isModuleDeclaration(node)\n    || isPropertyDeclaration(node)\n    || isPropertySignature(node)\n    || isSetAccessorDeclaration(node)\n    || isTypeAliasDeclaration(node)\n    || isVariableDeclaration(node);\n}\n\nfunction isResolvedName(params: IsResolvedNameParams): boolean {\n  const {\n    checker,\n    containingFileName,\n    localDeclarationNamesByName,\n    name,\n    program\n  } = params;\n\n  if (checker.getSymbolAtLocation(name)) {\n    return true;\n  }\n\n  // `Foo#bar` is a `JSDocMemberName`, which the checker resolves only through its right-hand member.\n  if (isJSDocMemberName(name) && checker.getSymbolAtLocation(name.right)) {\n    return true;\n  }\n\n  const [rootName = '', ...memberNames] = flattenName(name);\n  const index = getProgramIndex(program, checker);\n  const localRoots = (localDeclarationNamesByName.get(rootName) ?? []).map((declarationName) => checker.getSymbolAtLocation(declarationName));\n  const roots = [...localRoots, ...index.exportsByName.get(rootName) ?? [], findModule(program, checker, rootName, containingFileName)];\n\n  return roots.some((root) => !!resolveMemberPath(checker, root, memberNames));\n}\n\nfunction resolveAlias(checker: TypeChecker, symbol: TsSymbol): TsSymbol {\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  return (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);\n}\n\nfunction resolveMemberPath(checker: TypeChecker, root: TsSymbol | undefined, memberNames: readonly string[]): TsSymbol | undefined {\n  let current: TsSymbol | undefined = root;\n  for (const memberName of memberNames) {\n    if (!current) {\n      return undefined;\n    }\n    current = getMember(checker, current, memberName);\n  }\n  return current;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAkC1B,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;AAC5B,MAAM,+BAA+B;AACrC,MAAM,2BAA2B;AACjC,MAAM,gCAAgC;AACtC,MAAM,eAAe;AAErB,MAAM,oBAAoB,oBAAI,QAA+B;AAKtD,MAAM,wBAAyC;AAAA,EACpD,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,WAAW;AAEpC,WAAO;AAAA,MACL,QAAQ,MAAY;AAClB,cAAM,UAAU,SAAS;AACzB,cAAM,UAAU,QAAQ,eAAe;AACvC,cAAM,eAAe,SAAS,sBAAsB,IAAI,eAAe,IAAI,CAAqB;AAMhG,cAAM,QAAQ,oBAAI,IAAmB;AAMrC,cAAM,8BAA8B,oBAAI,IAA0B;AAElE,iBAAS,eAAe,WAAuB;AAC7C,cAAI,gBAAgB,SAAS,GAAG;AAC9B,kBAAM,IAAI,SAAS;AACnB;AAAA,UACF;AACA,uBAAa,WAAW,cAAc;AAAA,QACxC;AAEA,iBAAS,UAAU,QAAoB;AACrC,sCAA4B,QAAQ,2BAA2B;AAC/D,qBAAW,aAAa,wBAAwB,MAAM,GAAG;AACvD,2BAAe,SAAS;AAAA,UAC1B;AACA,uBAAa,QAAQ,SAAS;AAAA,QAChC;AAEA,iBAAS,mBAAmB,MAA2B;AACrD,cAAI,CAAC,KAAK,QAAQ,KAAK,KAAK,WAAW,GAAG,GAAG;AAC3C;AAAA,UACF;AAEA,gBAAM,WAAW,KAAK,KAAK,QAAQ;AACnC,gBAAM,aAAa,WAAW,KAAK;AACnC,gBAAM,cAAc,oBAAoB,KAAK,UAAU,KAAK,oBAAoB,KAAK,UAAU;AAC/F,cAAI,eAAe;AACnB,cAAI;AAEJ,cAAI,aAAa,QAAQ;AACvB,kBAAM,EAAE,YAAY,WAAW,IAAI,YAAY;AAC/C,2BAAe,YAAY,CAAC;AAC5B,kBAAM,eAAe,WAAW,SAAS,SAAS,YAAY,aAAa,QAAQ;AACnF,yBAAa,CAAC,CAAC,kBAAkB,SAAS,cAAc,WAAW,MAAM,wBAAwB,CAAC;AAAA,UACpG,OAAO;AACL,yBAAa,eAAe;AAAA,cAC1B;AAAA,cACA,oBAAoB,aAAa;AAAA,cACjC;AAAA,cACA,MAAM,KAAK;AAAA,cACX;AAAA,YACF,CAAC;AAAA,UACH;AAEA,cAAI,YAAY;AACd;AAAA,UACF;AAEA,kBAAQ,OAAO;AAAA,YACb,MAAM;AAAA,cACJ,MAAM;AAAA,YACR;AAAA,YACA,KAAK;AAAA,cACH,KAAK,QAAQ,WAAW,gBAAgB,KAAK,KAAK,OAAO,CAAC;AAAA,cAC1D,OAAO,QAAQ,WAAW,gBAAgB,KAAK,KAAK,SAAS,CAAC;AAAA,YAChE;AAAA,YACA,WAAW;AAAA,UACb,CAAC;AAAA,QACH;AAEA,kBAAU,YAAY;AACtB,mBAAW,QAAQ,OAAO;AACxB,6BAAmB,IAAI;AAAA,QACzB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,UAAU,GAAG;AAAA,IAChB;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AAEA,SAAS,4BAA4B,MAAY,6BAA8D;AAC7G,MAAI,CAAC,mBAAmB,IAAI,KAAK,CAAC,KAAK,QAAQ,CAAC,aAAa,KAAK,IAAI,GAAG;AACvE;AAAA,EACF;AACA,QAAM,QAAQ,4BAA4B,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC;AAClE,QAAM,KAAK,KAAK,IAAI;AACpB,8BAA4B,IAAI,KAAK,KAAK,MAAM,KAAK;AACvD;AAEA,SAAS,WAAW,SAAkB,SAAsB,WAAmB,oBAAkD;AAC/H,QAAM,gBAAgB,gBAAgB,SAAS,OAAO,EAAE,cAAc,IAAI,SAAS;AACnF,MAAI,eAAe;AACjB,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,kBAAkB,WAAW,oBAAoB,QAAQ,mBAAmB,GAAG,GAAG,EAAE,gBAAgB;AAC7H,QAAM,qBAAqB,qBAAqB,SAAY,SAAY,QAAQ,cAAc,gBAAgB;AAC9G,QAAM,iBAAiB,sBAAsB,QAAQ,oBAAoB,kBAAkB;AAC3F,SAAO,kBAAkB,uBAAuB,SAAS,SAAS,SAAS;AAC7E;AAEA,SAAS,uBAAuB,SAAkB,SAAsB,YAA0C;AAChH,QAAM,iBAAiB,WAAW,QAAQ,8BAA8B,EAAE,EAAE,QAAQ,+BAA+B,EAAE;AACrH,QAAM,WAAW,CAAC,IAAI,cAAc,IAAI,IAAI,cAAc,GAAG,YAAY,EAAE;AAC3E,aAAW,cAAc,QAAQ,eAAe,GAAG;AACjD,UAAM,uBAAuB,WAAW,SAAS,QAAQ,+BAA+B,EAAE;AAC1F,QAAI,SAAS,MAAM,CAAC,WAAW,CAAC,qBAAqB,SAAS,MAAM,CAAC,GAAG;AACtE;AAAA,IACF;AACA,UAAM,eAAe,QAAQ,oBAAoB,UAAU;AAC3D,QAAI,cAAc;AAChB,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,YAAY,MAA8C;AACjE,SAAO,aAAa,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,YAAY,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI;AACvF;AAEA,SAAS,UAAU,SAAsB,QAAkB,YAA0C;AACnG,QAAM,cAAc,yBAAyB,UAAU;AACvD,QAAM,SAAS,aAAa,SAAS,MAAM;AAE3C,QAAM,gBAAgB,OAAO,QAAQ,YAAY,YAAY,IAAI,SAAY,QAAQ,4BAA4B,YAAY,MAAM;AACnI,SAAO,gBACF,OAAO,SAAS,IAAI,WAAW,KAC/B,OAAO,SAAS,IAAI,WAAW,KAC/B,QAAQ,kBAAkB,QAAQ,wBAAwB,MAAM,GAAG,UAAU,KAC7E,QAAQ,kBAAkB,QAAQ,gBAAgB,MAAM,GAAG,UAAU;AAC5E;AAEA,SAAS,gBAAgB,SAAkB,SAAoC;AAC7E,MAAI,QAAQ,kBAAkB,IAAI,OAAO;AACzC,MAAI,OAAO;AACT,WAAO;AAAA,EACT;AAEA,UAAQ;AAAA,IACN,eAAe,oBAAI,IAAwB;AAAA,IAC3C,eAAe,oBAAI,IAAsB;AAAA,EAC3C;AAEA,QAAM,gBAA4B,CAAC;AACnC,aAAW,iBAAiB,QAAQ,kBAAkB,GAAG;AACvD,UAAM,cAAc,IAAI,cAAc,KAAK,WAAW,KAAK,EAAE,GAAG,aAAa;AAC7E,kBAAc,KAAK,aAAa;AAAA,EAClC;AACA,aAAW,cAAc,QAAQ,eAAe,GAAG;AACjD,UAAM,eAAe,QAAQ,oBAAoB,UAAU;AAC3D,QAAI,cAAc;AAChB,oBAAc,KAAK,YAAY;AAAA,IACjC;AAAA,EACF;AAEA,aAAW,gBAAgB,eAAe;AACxC,eAAW,gBAAgB,QAAQ,mBAAmB,YAAY,GAAG;AACnE,YAAM,UAAU,MAAM,cAAc,IAAI,aAAa,IAAI,KAAK,CAAC;AAC/D,cAAQ,KAAK,YAAY;AACzB,YAAM,cAAc,IAAI,aAAa,MAAM,OAAO;AAAA,IACpD;AAAA,EACF;AAEA,oBAAkB,IAAI,SAAS,KAAK;AACpC,SAAO;AACT;AAEA,SAAS,gBAAgB,MAAmC;AAC1D,SAAO,YAAY,IAAI,KAAK,gBAAgB,IAAI,KAAK,iBAAiB,IAAI;AAC5E;AAEA,SAAS,mBAAmB,MAAsC;AAChE,SAAO,mBAAmB,IAAI,KACzB,kBAAkB,IAAI,KACtB,sBAAsB,IAAI,KAC1B,yBAAyB,IAAI,KAC7B,uBAAuB,IAAI,KAC3B,oBAAoB,IAAI,KACxB,kBAAkB,IAAI,KACtB,oBAAoB,IAAI,KACxB,sBAAsB,IAAI,KAC1B,oBAAoB,IAAI,KACxB,yBAAyB,IAAI,KAC7B,uBAAuB,IAAI,KAC3B,sBAAsB,IAAI;AACjC;AAEA,SAAS,eAAe,QAAuC;AAC7D,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,MAAI,QAAQ,oBAAoB,IAAI,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,kBAAkB,IAAI,KAAK,QAAQ,oBAAoB,KAAK,KAAK,GAAG;AACtE,WAAO;AAAA,EACT;AAEA,QAAM,CAAC,WAAW,IAAI,GAAG,WAAW,IAAI,YAAY,IAAI;AACxD,QAAM,QAAQ,gBAAgB,SAAS,OAAO;AAC9C,QAAM,cAAc,4BAA4B,IAAI,QAAQ,KAAK,CAAC,GAAG,IAAI,CAAC,oBAAoB,QAAQ,oBAAoB,eAAe,CAAC;AAC1I,QAAM,QAAQ,CAAC,GAAG,YAAY,GAAG,MAAM,cAAc,IAAI,QAAQ,KAAK,CAAC,GAAG,WAAW,SAAS,SAAS,UAAU,kBAAkB,CAAC;AAEpI,SAAO,MAAM,KAAK,CAAC,SAAS,CAAC,CAAC,kBAAkB,SAAS,MAAM,WAAW,CAAC;AAC7E;AAEA,SAAS,aAAa,SAAsB,QAA4B;AAEtE,UAAQ,OAAO,QAAQ,YAAY,WAAW,IAAI,SAAS,QAAQ,iBAAiB,MAAM;AAC5F;AAEA,SAAS,kBAAkB,SAAsB,MAA4B,aAAsD;AACjI,MAAI,UAAgC;AACpC,aAAW,cAAc,aAAa;AACpC,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,IACT;AACA,cAAU,UAAU,SAAS,SAAS,UAAU;AAAA,EAClD;AACA,SAAO;AACT;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/no-unresolved-jsdoc-link.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: no-unresolved-jsdoc-link\n *\n * Reports a JSDoc `link`, `linkcode` or `linkplain` inline tag whose target no longer resolves to a symbol.\n *\n * A rename leaves `{@link OldName}` behind and nothing else reports it: `jsdoc/no-undefined-types` does not resolve\n * link targets, TSDoc checks only the tag syntax, and `tsc` parses JSDoc links without ever diagnosing them. So a dead\n * link survives until somebody happens to click it.\n *\n * A target resolves when any of these finds it, tried in order:\n *\n * 1. The type checker, at the comment's own location, exactly as editor go-to-definition does — so everything in\n *    scope there resolves: type parameters, parameters, imports, and the DOM / ES globals.\n * 2. A declaration anywhere in the same file — a function nested in another, a private method — which is out of\n *    scope at a `*Params` interface naming it, yet is exactly what a rename of it would break.\n * 3. The exports of any module in the program, by name. A comment routinely names a type its file never imports (an\n *    integration test naming the class it drives through `evalInObsidian`, a remark naming an Obsidian API), and the\n *    API docs generator resolves such a name library-wide too. This keeps the rule about DEAD links rather than\n *    about imports: a renamed or removed declaration is exported by no module, so it is still reported.\n * 4. A module named by its specifier or its path, in both TSDoc forms: `obsidian#Events#on` (the package as the first\n *    segment) and `error!errorToString` / `obsidian/components/plugin-gate-component!PluginConflictSeverity.Warn`\n *    (a module path, ending with `!`) — plus TypeScript's own `import('./module.ts').Member`. A path matches any\n *    source file in the program whose path ends with it.\n *\n * After the first segment, each further `.` / `#` segment is looked up as a member: a namespace or module export, a\n * static or instance member, or a property of the previous member's type — so `App.vault.adapter` resolves.\n *\n * A link that is not a code reference is skipped: a URL (`{@link https://example.com}`) and a JSDoc namepath\n * (`{@link module:foo}`) both parse as a name followed by text starting with `:`, and a link with no name has\n * nothing to resolve.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type {\n  ClassDeclaration,\n  EntityName,\n  EnumDeclaration,\n  FunctionDeclaration,\n  GetAccessorDeclaration,\n  Identifier,\n  InterfaceDeclaration,\n  JSDocLink,\n  JSDocLinkCode,\n  JSDocLinkPlain,\n  JSDocMemberName,\n  MethodDeclaration,\n  MethodSignature,\n  ModuleDeclaration,\n  Node,\n  Program,\n  PropertyDeclaration,\n  PropertySignature,\n  SetAccessorDeclaration,\n  Symbol as TsSymbol,\n  TypeAliasDeclaration,\n  TypeChecker,\n  VariableDeclaration\n} from 'typescript';\n\nimport {\n  escapeLeadingUnderscores,\n  forEachChild,\n  getJSDocCommentsAndTags,\n  isClassDeclaration,\n  isEnumDeclaration,\n  isFunctionDeclaration,\n  isGetAccessorDeclaration,\n  isIdentifier,\n  isInterfaceDeclaration,\n  isJSDocLink,\n  isJSDocLinkCode,\n  isJSDocLinkPlain,\n  isJSDocMemberName,\n  isMethodDeclaration,\n  isMethodSignature,\n  isModuleDeclaration,\n  isPropertyDeclaration,\n  isPropertySignature,\n  isSetAccessorDeclaration,\n  isTypeAliasDeclaration,\n  isVariableDeclaration,\n  resolveModuleName,\n  SymbolFlags,\n  sys\n} from 'typescript';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\n/**\n * Message ID reported when a JSDoc link target does not resolve to a symbol.\n */\nexport const MESSAGE_ID = 'noUnresolvedJsdocLink';\n\ninterface IsResolvedNameParams {\n  readonly checker: TypeChecker;\n  readonly containingFileName: string;\n  readonly localDeclarationNamesByName: ReadonlyMap<string, readonly Identifier[]>;\n  readonly name: EntityName | JSDocMemberName;\n  readonly program: Program;\n}\n\ntype JSDocLinkLike = JSDocLink | JSDocLinkCode | JSDocLinkPlain;\n\ntype LocalDeclaration =\n  | ClassDeclaration\n  | EnumDeclaration\n  | FunctionDeclaration\n  | GetAccessorDeclaration\n  | InterfaceDeclaration\n  | MethodDeclaration\n  | MethodSignature\n  | ModuleDeclaration\n  | PropertyDeclaration\n  | PropertySignature\n  | SetAccessorDeclaration\n  | TypeAliasDeclaration\n  | VariableDeclaration;\n\ntype ModulePathMatchGroups = Readonly<Record<'memberPath' | 'modulePath', string>>;\n\ninterface ProgramIndex {\n  readonly exportsByName: Map<string, TsSymbol[]>;\n  readonly modulesByPath: Map<string, TsSymbol>;\n}\n\nconst MODULE_PATH_REG_EXP = /^(?<modulePath>[^\\s!|}]*)!(?<memberPath>[\\w$.#]+)/;\nconst IMPORT_TYPE_REG_EXP = /^import\\(\\s*(?<quote>['\"])(?<modulePath>[^'\"]+)\\k<quote>\\s*\\)\\.(?<memberPath>[\\w$.#]+)/;\nconst RELATIVE_PATH_PREFIX_REG_EXP = /^(?:\\.\\.?\\/)+/;\nconst MEMBER_SEPARATOR_REG_EXP = /[.#]/;\nconst SOURCE_FILE_EXTENSION_REG_EXP = /(?:\\.d)?\\.[cm]?tsx?$/;\nconst INDEX_SUFFIX = '/index';\n\nconst programIndexCache = new WeakMap<Program, ProgramIndex>();\n\n/**\n * The ESLint rule that reports JSDoc links whose target does not resolve.\n */\nexport const noUnresolvedJsdocLink: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n\n    return {\n      Program(node): void {\n        const program = services.program;\n        const checker = program.getTypeChecker();\n        const tsSourceFile = services.esTreeNodeToTSNodeMap.get(toTSESTreeNode(node) as TSESTree.Program);\n\n        /*\n         * The same link is reachable more than once: a parameter returns its own `@param` tag, which its function's\n         * JSDoc block also contains. So deduplicate on the link itself rather than on the JSDoc node.\n         */\n        const links = new Set<JSDocLinkLike>();\n\n        /*\n         * A link may name a declaration further down the file, so the whole file is walked before any link is\n         * resolved.\n         */\n        const localDeclarationNamesByName = new Map<string, Identifier[]>();\n\n        function visitJsDocNode(jsDocNode: Node): void {\n          if (isJSDocLinkLike(jsDocNode)) {\n            links.add(jsDocNode);\n            return;\n          }\n          forEachChild(jsDocNode, visitJsDocNode);\n        }\n\n        function visitNode(tsNode: Node): void {\n          collectLocalDeclarationName(tsNode, localDeclarationNamesByName);\n          for (const jsDocNode of getJSDocCommentsAndTags(tsNode)) {\n            visitJsDocNode(jsDocNode);\n          }\n          forEachChild(tsNode, visitNode);\n        }\n\n        function reportIfUnresolved(link: JSDocLinkLike): void {\n          if (!link.name || link.text.startsWith(':')) {\n            return;\n          }\n\n          const nameText = link.name.getText();\n          const fullTarget = nameText + link.text;\n          const moduleMatch = IMPORT_TYPE_REG_EXP.exec(fullTarget) ?? MODULE_PATH_REG_EXP.exec(fullTarget);\n          let reportedName = nameText;\n          let isResolved: boolean;\n\n          if (moduleMatch?.groups) {\n            const { memberPath, modulePath } = moduleMatch.groups as ModulePathMatchGroups;\n            reportedName = moduleMatch[0];\n            const moduleSymbol = findModule(program, checker, modulePath, tsSourceFile.fileName);\n            isResolved = !!resolveMemberPath(checker, moduleSymbol, memberPath.split(MEMBER_SEPARATOR_REG_EXP));\n          } else {\n            isResolved = isResolvedName({\n              checker,\n              containingFileName: tsSourceFile.fileName,\n              localDeclarationNamesByName,\n              name: link.name,\n              program\n            });\n          }\n\n          if (isResolved) {\n            return;\n          }\n\n          context.report({\n            data: {\n              name: reportedName\n            },\n            loc: {\n              end: context.sourceCode.getLocFromIndex(link.name.getEnd()),\n              start: context.sourceCode.getLocFromIndex(link.name.getStart())\n            },\n            messageId: MESSAGE_ID\n          });\n        }\n\n        visitNode(tsSourceFile);\n        for (const link of links) {\n          reportIfUnresolved(link);\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow JSDoc link tags whose target does not resolve to a symbol'\n    },\n    messages: {\n      [MESSAGE_ID]: 'JSDoc link target `{{name}}` does not resolve. Was it renamed or removed?'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\nfunction collectLocalDeclarationName(node: Node, localDeclarationNamesByName: Map<string, Identifier[]>): void {\n  if (!isLocalDeclaration(node) || !node.name || !isIdentifier(node.name)) {\n    return;\n  }\n  const names = localDeclarationNamesByName.get(node.name.text) ?? [];\n  names.push(node.name);\n  localDeclarationNamesByName.set(node.name.text, names);\n}\n\nfunction findModule(program: Program, checker: TypeChecker, specifier: string, containingFileName: string): TsSymbol | undefined {\n  const ambientModule = getProgramIndex(program, checker).modulesByPath.get(specifier);\n  if (ambientModule) {\n    return ambientModule;\n  }\n\n  const resolvedFileName = resolveModuleName(specifier, containingFileName, program.getCompilerOptions(), sys).resolvedModule?.resolvedFileName;\n  const resolvedSourceFile = resolvedFileName === undefined ? undefined : program.getSourceFile(resolvedFileName);\n  const resolvedModule = resolvedSourceFile && checker.getSymbolAtLocation(resolvedSourceFile);\n  return resolvedModule ?? findModuleByPathSuffix(program, checker, specifier);\n}\n\nfunction findModuleByPathSuffix(program: Program, checker: TypeChecker, modulePath: string): TsSymbol | undefined {\n  const normalizedPath = modulePath.replace(RELATIVE_PATH_PREFIX_REG_EXP, '').replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n  const suffixes = [`/${normalizedPath}`, `/${normalizedPath}${INDEX_SUFFIX}`];\n  for (const sourceFile of program.getSourceFiles()) {\n    const pathWithoutExtension = sourceFile.fileName.replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n    if (suffixes.every((suffix) => !pathWithoutExtension.endsWith(suffix))) {\n      continue;\n    }\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      return moduleSymbol;\n    }\n  }\n  return undefined;\n}\n\nfunction flattenName(name: EntityName | JSDocMemberName): string[] {\n  return isIdentifier(name) ? [name.text] : [...flattenName(name.left), name.right.text];\n}\n\nfunction getMember(checker: TypeChecker, $symbol: TsSymbol, memberName: string): TsSymbol | undefined {\n  const escapedName = escapeLeadingUnderscores(memberName);\n  const target = resolveAlias(checker, $symbol);\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  const moduleExport = (target.flags & SymbolFlags.Module) === 0 ? undefined : checker.tryGetMemberInModuleExports(memberName, target);\n  return moduleExport\n    ?? target.exports?.get(escapedName)\n    ?? target.members?.get(escapedName)\n    ?? checker.getPropertyOfType(checker.getDeclaredTypeOfSymbol(target), memberName)\n    ?? checker.getPropertyOfType(checker.getTypeOfSymbol(target), memberName);\n}\n\nfunction getProgramIndex(program: Program, checker: TypeChecker): ProgramIndex {\n  let index = programIndexCache.get(program);\n  if (index) {\n    return index;\n  }\n\n  index = {\n    exportsByName: new Map<string, TsSymbol[]>(),\n    modulesByPath: new Map<string, TsSymbol>()\n  };\n\n  const moduleSymbols: TsSymbol[] = [];\n  for (const ambientModule of checker.getAmbientModules()) {\n    index.modulesByPath.set(ambientModule.name.replaceAll('\"', ''), ambientModule);\n    moduleSymbols.push(ambientModule);\n  }\n  for (const sourceFile of program.getSourceFiles()) {\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      moduleSymbols.push(moduleSymbol);\n    }\n  }\n\n  for (const moduleSymbol of moduleSymbols) {\n    for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {\n      const symbols = index.exportsByName.get(exportSymbol.name) ?? [];\n      symbols.push(exportSymbol);\n      index.exportsByName.set(exportSymbol.name, symbols);\n    }\n  }\n\n  programIndexCache.set(program, index);\n  return index;\n}\n\nfunction isJSDocLinkLike(node: Node): node is JSDocLinkLike {\n  return isJSDocLink(node) || isJSDocLinkCode(node) || isJSDocLinkPlain(node);\n}\n\nfunction isLocalDeclaration(node: Node): node is LocalDeclaration {\n  return isClassDeclaration(node)\n    || isEnumDeclaration(node)\n    || isFunctionDeclaration(node)\n    || isGetAccessorDeclaration(node)\n    || isInterfaceDeclaration(node)\n    || isMethodDeclaration(node)\n    || isMethodSignature(node)\n    || isModuleDeclaration(node)\n    || isPropertyDeclaration(node)\n    || isPropertySignature(node)\n    || isSetAccessorDeclaration(node)\n    || isTypeAliasDeclaration(node)\n    || isVariableDeclaration(node);\n}\n\nfunction isResolvedName(params: IsResolvedNameParams): boolean {\n  const {\n    checker,\n    containingFileName,\n    localDeclarationNamesByName,\n    name,\n    program\n  } = params;\n\n  if (checker.getSymbolAtLocation(name)) {\n    return true;\n  }\n\n  // `Foo#bar` is a `JSDocMemberName`, which the checker resolves only through its right-hand member.\n  if (isJSDocMemberName(name) && checker.getSymbolAtLocation(name.right)) {\n    return true;\n  }\n\n  const [rootName = '', ...memberNames] = flattenName(name);\n  const index = getProgramIndex(program, checker);\n  const localRoots = (localDeclarationNamesByName.get(rootName) ?? []).map((declarationName) => checker.getSymbolAtLocation(declarationName));\n  const roots = [...localRoots, ...index.exportsByName.get(rootName) ?? [], findModule(program, checker, rootName, containingFileName)];\n\n  return roots.some((root) => !!resolveMemberPath(checker, root, memberNames));\n}\n\nfunction resolveAlias(checker: TypeChecker, $symbol: TsSymbol): TsSymbol {\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  return ($symbol.flags & SymbolFlags.Alias) === 0 ? $symbol : checker.getAliasedSymbol($symbol);\n}\n\nfunction resolveMemberPath(checker: TypeChecker, root: TsSymbol | undefined, memberNames: readonly string[]): TsSymbol | undefined {\n  let current: TsSymbol | undefined = root;\n  for (const memberName of memberNames) {\n    if (!current) {\n      return undefined;\n    }\n    current = getMember(checker, current, memberName);\n  }\n  return current;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/linters/eslint-rules/prefer-noop-async.mjs

@@ -2,20 +2,92 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
 
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const FUNCTION_MODULE = "@mnaoumov/typescript-lib/function";
 const MESSAGE_ID = "preferNoopAsync";
 const preferNoopAsync = {
   create(context) {
     return {
       "CallExpression"(node) {
         const callNode = toTSESTreeNode(node);
-        if (!isPromiseResolveWithNoArguments(callNode)) {
+        if (!isPromiseResolveWithNoArguments(callNode) || isLocallyBoundPromise(context.sourceCode.getScope(node), callNode)) {
           return;
         }
         context.report({
           fix(fixer) {
-            return fixer.replaceText(node, "noopAsync()");
+            const sourceCode = context.sourceCode;
+            const seen = /* @__PURE__ */ new Set();
+            for (let scope = sourceCode.getScope(node); scope; scope = scope.upper) {
+              for (const variable of scope.variables) {
+                if (seen.has(variable.name)) {
+                  continue;
+                }
+                seen.add(variable.name);
+                for (const definition of variable.defs) {
+                  if (definition.type !== "ImportBinding") {
+                    continue;
+                  }
+                  const specifier = toTSESTreeNode(definition.node);
+                  const declaration = toTSESTreeNode(definition.parent);
+                  if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type" && declaration.importKind !== "type" && declaration.source.value === FUNCTION_MODULE && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "noopAsync") {
+                    return fixer.replaceText(node, `${variable.name}()`);
+                  }
+                }
+              }
+            }
+            if (sourceCode.ast.sourceType !== "module") {
+              return null;
+            }
+            const names = new Set(sourceCode.getTokens(sourceCode.ast).map((token) => token.value));
+            let name = "noopAsync";
+            let suffix = 0;
+            while (names.has(name)) {
+              name = `noopAsync${String(++suffix)}`;
+            }
+            const binding = name === "noopAsync" ? name : `noopAsync as ${name}`;
+            const firstStatement = ensureNonNullable(sourceCode.ast.body.find((statement) => !("directive" in statement && typeof statement.directive === "string")));
+            const firstToken = sourceCode.getFirstToken(firstStatement);
+            return [
+              fixer.insertTextBefore(firstToken, `import { ${binding} } from '${FUNCTION_MODULE}';
+`),
+              fixer.replaceText(node, `${name}()`)
+            ];
           },
           messageId: MESSAGE_ID,
           node
@@ -35,6 +107,11 @@ const preferNoopAsync = {
     type: "suggestion"
   }
 };
+function isLocallyBoundPromise(scope, node) {
+  const callee = node.callee;
+  const reference = ensureNonNullable(scope.references.find((candidate) => toTSESTreeNode(candidate.identifier) === callee.object));
+  return (reference.resolved?.defs.length ?? 0) > 0;
+}
 function isPromiseResolveWithNoArguments(node) {
   const callee = node.callee;
   return node.arguments.length === 0 && callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "Promise" && callee.property.type === "Identifier" && callee.property.name === "resolve";
@@ -43,4 +120,4 @@ export {
   MESSAGE_ID,
   preferNoopAsync
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/prefer-noop-async.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: prefer-noop-async\n *\n * Reports `await Promise.resolve()` and suggests replacing it with\n * `await noopAsync()` for consistency and readability.\n *\n * The fix reuses a visible value import from `@mnaoumov/typescript-lib/function`,\n * or adds a collision-free import. Scripts without one retain the diagnostic only.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\nconst FUNCTION_MODULE = '@mnaoumov/typescript-lib/function';\n/**\nMessage ID reported when `Promise.resolve()` is used for an async no-op instead of `noopAsync()`.\n */\nexport const MESSAGE_ID = 'preferNoopAsync';\n\n/**\n * ESLint rule preferring `noopAsync()` over `Promise.resolve()` for an async no-op.\n */\nexport const preferNoopAsync: Rule.RuleModule = {\n  create(context) {\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n\n        if (!isPromiseResolveWithNoArguments(callNode) || isLocallyBoundPromise(context.sourceCode.getScope(node), callNode)) {\n          return;\n        }\n\n        context.report({\n          fix(fixer) {\n            const sourceCode = context.sourceCode;\n            const seen = new Set<string>();\n            for (let scope: null | Scope.Scope = sourceCode.getScope(node); scope; scope = scope.upper) {\n              for (const variable of scope.variables) {\n                if (seen.has(variable.name)) {\n                  continue;\n                }\n                seen.add(variable.name);\n                for (const definition of variable.defs) {\n                  if (definition.type !== 'ImportBinding') {\n                    continue;\n                  }\n                  const specifier = toTSESTreeNode(definition.node);\n                  const declaration = toTSESTreeNode(definition.parent) as TSESTree.ImportDeclaration;\n                  if (\n                    specifier.type === AST_NODE_TYPES.ImportSpecifier\n                    && specifier.importKind !== 'type' && declaration.importKind !== 'type'\n                    && declaration.source.value === FUNCTION_MODULE\n                    && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === 'noopAsync'\n                  ) {\n                    return fixer.replaceText(node, `${variable.name}()`);\n                  }\n                }\n              }\n            }\n\n            // A script cannot accept an ESM import. Leave its diagnostic for a manual edit.\n            if (sourceCode.ast.sourceType !== 'module') {\n              return null;\n            }\n            // Include references as well as declarations, so an import never captures an existing free read.\n            const names = new Set(sourceCode.getTokens(sourceCode.ast).map((token) => token.value));\n            let name = 'noopAsync';\n            let suffix = 0;\n            while (names.has(name)) {\n              name = `noopAsync${String(++suffix)}`;\n            }\n            const binding = name === 'noopAsync' ? name : `noopAsync as ${name}`;\n            const firstStatement = ensureNonNullable(sourceCode.ast.body.find((statement) => !('directive' in statement && typeof statement.directive === 'string')));\n            const firstToken = sourceCode.getFirstToken(firstStatement);\n            // The reported call guarantees a non-empty program, including when a hashbang precedes it.\n            return [\n              fixer.insertTextBefore(firstToken, `import { ${binding} } from '${FUNCTION_MODULE}';\\n`),\n              fixer.replaceText(node, `${name}()`)\n            ];\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Prefer `noopAsync()` over `Promise.resolve()`'\n    },\n    fixable: 'code',\n    messages: {\n      [MESSAGE_ID]: 'Use `noopAsync()` instead of `Promise.resolve()` for async no-ops.'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\n/**\n * Checks whether the `Promise` of a `Promise.resolve()` call resolves to a binding the code declares itself,\n * such as a local variable, a parameter or an import, rather than the global.\n *\n * @param scope - The scope enclosing the call.\n * @param node - The `Promise.resolve()` call expression.\n * @returns `true` if `Promise` is bound by a declaration in the code.\n */\nfunction isLocallyBoundPromise(scope: Scope.Scope, node: TSESTree.CallExpression): boolean {\n  const callee = node.callee as TSESTree.MemberExpression;\n  const reference = ensureNonNullable(scope.references.find((candidate) => toTSESTreeNode(candidate.identifier) === callee.object));\n  // A global `Promise` resolves to a variable without definitions, or to nothing when no globals are configured.\n  return (reference.resolved?.defs.length ?? 0) > 0;\n}\n\n/**\n * Checks whether a call expression is `Promise.resolve()` with no arguments.\n *\n * @param node - The call expression node.\n * @returns `true` if the node is `Promise.resolve()` with no arguments.\n */\nfunction isPromiseResolveWithNoArguments(node: TSESTree.CallExpression): boolean {\n  const callee = node.callee;\n\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values. */\n  return node.arguments.length === 0\n    && callee.type === 'MemberExpression'\n    && callee.object.type === 'Identifier' && callee.object.name === 'Promise'\n    && callee.property.type === 'Identifier' && callee.property.name === 'resolve';\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values. */\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/linters/eslint-rules/readonly-member-arrays.d.mts

@@ -0,0 +1,6 @@
+/// <reference path="../../library-references.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * Opt-in array immutability policy, independent of readonly property references.
+ */
+export declare const readonlyMemberArrays: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/readonly-member-arrays.mjs

@@ -0,0 +1,106 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const readonlyMemberArrays = {
+  create(context) {
+    function check(node, property) {
+      if (node.type === AST_NODE_TYPES.TSUnionType || node.type === AST_NODE_TYPES.TSIntersectionType) {
+        for (const member of node.types) {
+          check(member, property);
+        }
+        return;
+      }
+      if (node.type === AST_NODE_TYPES.TSArrayType) {
+        context.report({
+          messageId: "readonly",
+          node,
+          suggest: [{ fix: (fixer) => fixer.insertTextBefore(node, "readonly "), messageId: "review" }]
+        });
+        return;
+      }
+      if (node.type !== AST_NODE_TYPES.TSTypeReference || node.typeName.type !== AST_NODE_TYPES.Identifier || node.typeName.name !== "Array" || node.typeArguments?.params.length !== 1) {
+        return;
+      }
+      let scope = context.sourceCode.getScope(property);
+      let canSuggest = true;
+      while (scope) {
+        if (scope.set.get("Array")?.defs.length) {
+          return;
+        }
+        if (scope.set.get("ReadonlyArray")?.defs.length) {
+          canSuggest = false;
+        }
+        scope = scope.upper;
+      }
+      context.report({
+        messageId: "readonly",
+        node,
+        suggest: canSuggest ? [{
+          fix: (fixer) => fixer.replaceTextRange(node.typeName.range, "ReadonlyArray"),
+          messageId: "review"
+        }] : []
+      });
+    }
+    function visitProperty(node) {
+      const property = toTSESTreeNode(node);
+      if (property.typeAnnotation) {
+        check(property.typeAnnotation.typeAnnotation, node);
+      }
+    }
+    return {
+      "TSInterfaceDeclaration TSPropertySignature": visitProperty,
+      "TSTypeAliasDeclaration TSPropertySignature": visitProperty
+    };
+  },
+  meta: {
+    docs: { description: "Require readonly member arrays as an explicit collection immutability policy" },
+    hasSuggestions: true,
+    messages: {
+      readonly: "Use a readonly member array, or disable this rule with a reason for mutation.",
+      review: "Make this array readonly after reviewing mutations and assignability."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+export {
+  readonlyMemberArrays
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/markdownlint.mjs

@@ -48,6 +48,7 @@ import {
   matchesGlob,
   relative
 } from "node:path";
+import { getBulkConcurrency } from "../bulk-concurrency.mjs";
 import { getNonIgnoredFiles } from "../git.mjs";
 import { resolveToolCommand } from "../package-manager.mjs";
 import { RepoPaths } from "../repo-paths.mjs";
@@ -92,7 +93,10 @@ async function lint(options) {
   }
   await execFromRoot([
     ...resolveToolCommand({ tool: "linkinator" }),
-    "--retry",
+    "--concurrency",
+    String(getBulkConcurrency(LINK_CHECK_CONCURRENCY)),
+    "--timeout",
+    String(LINK_CHECK_TIMEOUT_IN_MILLISECONDS),
     "--retry-errors",
     "--retry-errors-count",
     "3",
@@ -108,6 +112,8 @@ async function lint(options) {
   ]);
 }
 const MARKDOWN_PATHSPEC = "*.md";
+const LINK_CHECK_CONCURRENCY = 100;
+const LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 3e4;
 async function getMarkdownFiles() {
   const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });
   return nonIgnoredFiles ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path)) : await toArray(glob(["**/*.md"], {
@@ -121,4 +127,4 @@ async function getMarkdownFiles() {
 export {
   lint
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/linters/markdownlint.ts"],"sourcesContent":["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { basename } from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport {\n  matchesGlob,\n  relative\n} from 'node:path';\n\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  checkIsInNodeModules,\n  NODE_MODULES_IGNORE_GLOB\n} from './markdownlint-ignores.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Without it,\n   * `markdownlint-cli2` runs with its own defaults.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Globs, relative to the root folder, of markdown files to leave out of the `linkinator` pass only;\n   * `markdownlint-cli2` still lints them.\n   *\n   * For a documentation site whose pages link to each other base-absolutely (`/<site-base>/guides/...`): those\n   * links resolve only against the BUILT site, so `linkinator` reports each one as a 404, and the site's own\n   * build is what checks them.\n   *\n   * @example `['docs/**']`\n   */\n  readonly linkCheckExcludeGlobs?: readonly string[] | undefined;\n\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { defaultConfigFilePath, linkCheckExcludeGlobs = [], paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    RepoPaths.MarkdownlintCli2ConfigJsonc,\n    RepoPaths.MarkdownlintCli2ConfigYaml,\n    RepoPaths.MarkdownlintCli2ConfigCjs,\n    RepoPaths.MarkdownlintCli2ConfigMjs,\n    RepoPaths.MarkdownlintConfigJsonc,\n    RepoPaths.MarkdownlintConfigJson,\n    RepoPaths.MarkdownlintConfigYaml,\n    RepoPaths.MarkdownlintConfigYml,\n    RepoPaths.MarkdownlintConfigCjs,\n    RepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const doesConfigFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!doesConfigFileExist && defaultConfigFilePath) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [RepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot([...resolveToolCommand({ tool: 'markdownlint-cli2' }), ...(shouldFix ? ['--fix'] : []), { batchedArguments: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replaceAll('\\\\', '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  const linkCheckFiles = mdFiles.filter((mdFile) => linkCheckExcludeGlobs.every((excludeGlob) => !matchesGlob(mdFile, excludeGlob)));\n  // `linkinator` with no LOCATION prints its usage and exits non-zero, so a list emptied by the exclusions has nothing to check.\n  if (linkCheckFiles.length === 0) {\n    return;\n  }\n  // A host that rate-limits the runner (forum.obsidian.md answers a CI burst with 429) is retried with a jitter of up to\n  // 5 s, which `linkinator` reads as MILLISECONDS, so the retries do not all land in the same instant. A link still\n  // answering 429 once they are spent is a warning, not a failure: a rate limit says nothing about whether the link exists.\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'linkinator' }),\n    '--retry',\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5000',\n    '--status-code',\n    '429:warn',\n    '--url-rewrite-search',\n    String.raw`https://www\\.npmjs\\.com/package/`,\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArguments: linkCheckFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\n\n/**\n * Lists the markdown files to hand to `linkinator`.\n *\n * `linkinator` takes a file list rather than an ignore configuration, so the gitignored files have to be\n * dropped before it is invoked. Git itself answers that (nested ignore files, `!` negations and all); the\n * hand-maintained glob exclusions below are only the fallback for a checkout without git, and they are the\n * very lists this indirection exists to stop from drifting.\n *\n * The `node_modules` filter is applied to the git-derived list too, and deliberately so: git only skips\n * what the repository asked it to skip, and a repository can deliberately TRACK a vendored `node_modules`\n * tree. That is the one exclusion `.gitignore` cannot answer — see `markdownlint-ignores.ts`. Applying it\n * here keeps `linkinator` in step with the markdownlint half, which ignores the same paths by glob.\n *\n * @returns A {@link Promise} that resolves with the markdown file paths, relative to the root folder.\n */\nasync function getMarkdownFiles(): Promise<string[]> {\n  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });\n  return nonIgnoredFiles\n    ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path))\n    : (await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        NODE_MODULES_IGNORE_GLOB\n      ]\n    })));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA0CP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,uBAAuB,wBAAwB,CAAC,GAAG,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACpG,QAAM,cAAc;AAAA,IAClB,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,EACZ;AAEA,QAAM,sBAAsB,YAAY,KAAK,CAAC,eAAe;AAC3D,UAAM,iBAAiB,wBAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,WAAO,WAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,uBAAuB,uBAAuB;AACjD,mBAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,GAAG,uBAAuB,wBAAwB,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC,CAAC;AAAA,EACpG;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,UAAU,aAAa;AAEhE,QAAM,aAAa,CAAC,GAAG,mBAAmB,EAAE,MAAM,oBAAoB,CAAC,GAAG,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,kBAAkB,QAAQ,CAAC,CAAC;AAGzI,QAAM,aAAa,cAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,MAAM,SAAS,YAAY,CAAC,EAAE,WAAW,MAAM,GAAG,KAAK,CAAC,IACnE,MAAM,iBAAiB;AAE3B,QAAM,iBAAiB,QAAQ,OAAO,CAAC,WAAW,sBAAsB,MAAM,CAAC,gBAAgB,CAAC,YAAY,QAAQ,WAAW,CAAC,CAAC;AAEjI,MAAI,eAAe,WAAW,GAAG;AAC/B;AAAA,EACF;AAIA,QAAM,aAAa;AAAA,IACjB,GAAG,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAAA,IAC5C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,EAAE,kBAAkB,eAAe;AAAA,EACrC,CAAC;AACH;AAKA,MAAM,oBAAoB;AAiB1B,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,MAAM,mBAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,SAAO,kBACH,gBAAgB,OAAO,CAAC,SAAS,CAAC,qBAAqB,IAAI,CAAC,IAC3D,MAAM,QAAQ,KAAK,CAAC,SAAS,GAAG;AAAA,IACjC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACN;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/linters/markdownlint.ts"],"sourcesContent":["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { basename } from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport {\n  matchesGlob,\n  relative\n} from 'node:path';\n\nimport { getBulkConcurrency } from '../bulk-concurrency.ts';\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  checkIsInNodeModules,\n  NODE_MODULES_IGNORE_GLOB\n} from './markdownlint-ignores.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Without it,\n   * `markdownlint-cli2` runs with its own defaults.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Globs, relative to the root folder, of markdown files to leave out of the `linkinator` pass only;\n   * `markdownlint-cli2` still lints them.\n   *\n   * For a documentation site whose pages link to each other base-absolutely (`/<site-base>/guides/...`): those\n   * links resolve only against the BUILT site, so `linkinator` reports each one as a 404, and the site's own\n   * build is what checks them.\n   *\n   * @example `['docs/**']`\n   */\n  readonly linkCheckExcludeGlobs?: readonly string[] | undefined;\n\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { defaultConfigFilePath, linkCheckExcludeGlobs = [], paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    RepoPaths.MarkdownlintCli2ConfigJsonc,\n    RepoPaths.MarkdownlintCli2ConfigYaml,\n    RepoPaths.MarkdownlintCli2ConfigCjs,\n    RepoPaths.MarkdownlintCli2ConfigMjs,\n    RepoPaths.MarkdownlintConfigJsonc,\n    RepoPaths.MarkdownlintConfigJson,\n    RepoPaths.MarkdownlintConfigYaml,\n    RepoPaths.MarkdownlintConfigYml,\n    RepoPaths.MarkdownlintConfigCjs,\n    RepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const doesConfigFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!doesConfigFileExist && defaultConfigFilePath) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [RepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot([...resolveToolCommand({ tool: 'markdownlint-cli2' }), ...(shouldFix ? ['--fix'] : []), { batchedArguments: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replaceAll('\\\\', '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  const linkCheckFiles = mdFiles.filter((mdFile) => linkCheckExcludeGlobs.every((excludeGlob) => !matchesGlob(mdFile, excludeGlob)));\n  // `linkinator` with no LOCATION prints its usage and exits non-zero, so a list emptied by the exclusions has nothing to check.\n  if (linkCheckFiles.length === 0) {\n    return;\n  }\n  // Error retries use millisecond jitter. Omit --retry: its separate Retry-After mode can sleep for thousands\n  // of seconds on a 429 we already accept as a warning. Request timeouts remain errors and keep their retries.\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'linkinator' }),\n    '--concurrency',\n    String(getBulkConcurrency(LINK_CHECK_CONCURRENCY)),\n    '--timeout',\n    String(LINK_CHECK_TIMEOUT_IN_MILLISECONDS),\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5000',\n    '--status-code',\n    '429:warn',\n    '--url-rewrite-search',\n    String.raw`https://www\\.npmjs\\.com/package/`,\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArguments: linkCheckFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\nconst LINK_CHECK_CONCURRENCY = 100;\nconst LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 30_000;\n\n/**\n * Lists the markdown files to hand to `linkinator`.\n *\n * `linkinator` takes a file list rather than an ignore configuration, so the gitignored files have to be\n * dropped before it is invoked. Git itself answers that (nested ignore files, `!` negations and all); the\n * hand-maintained glob exclusions below are only the fallback for a checkout without git, and they are the\n * very lists this indirection exists to stop from drifting.\n *\n * The `node_modules` filter is applied to the git-derived list too, and deliberately so: git only skips\n * what the repository asked it to skip, and a repository can deliberately TRACK a vendored `node_modules`\n * tree. That is the one exclusion `.gitignore` cannot answer — see `markdownlint-ignores.ts`. Applying it\n * here keeps `linkinator` in step with the markdownlint half, which ignores the same paths by glob.\n *\n * @returns A {@link Promise} that resolves with the markdown file paths, relative to the root folder.\n */\nasync function getMarkdownFiles(): Promise<string[]> {\n  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });\n  return nonIgnoredFiles\n    ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path))\n    : (await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        NODE_MODULES_IGNORE_GLOB\n      ]\n    })));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA0CP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,uBAAuB,wBAAwB,CAAC,GAAG,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACpG,QAAM,cAAc;AAAA,IAClB,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,EACZ;AAEA,QAAM,sBAAsB,YAAY,KAAK,CAAC,eAAe;AAC3D,UAAM,iBAAiB,wBAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,WAAO,WAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,uBAAuB,uBAAuB;AACjD,mBAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,GAAG,uBAAuB,wBAAwB,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC,CAAC;AAAA,EACpG;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,UAAU,aAAa;AAEhE,QAAM,aAAa,CAAC,GAAG,mBAAmB,EAAE,MAAM,oBAAoB,CAAC,GAAG,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,kBAAkB,QAAQ,CAAC,CAAC;AAGzI,QAAM,aAAa,cAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,MAAM,SAAS,YAAY,CAAC,EAAE,WAAW,MAAM,GAAG,KAAK,CAAC,IACnE,MAAM,iBAAiB;AAE3B,QAAM,iBAAiB,QAAQ,OAAO,CAAC,WAAW,sBAAsB,MAAM,CAAC,gBAAgB,CAAC,YAAY,QAAQ,WAAW,CAAC,CAAC;AAEjI,MAAI,eAAe,WAAW,GAAG;AAC/B;AAAA,EACF;AAGA,QAAM,aAAa;AAAA,IACjB,GAAG,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAAA,IAC5C;AAAA,IACA,OAAO,mBAAmB,sBAAsB,CAAC;AAAA,IACjD;AAAA,IACA,OAAO,kCAAkC;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,EAAE,kBAAkB,eAAe;AAAA,EACrC,CAAC;AACH;AAKA,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,qCAAqC;AAiB3C,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,MAAM,mBAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,SAAO,kBACH,gBAAgB,OAAO,CAAC,SAAS,CAAC,qBAAqB,IAAI,CAAC,IAC3D,MAAM,QAAQ,KAAK,CAAC,SAAS,GAAG;AAAA,IACjC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACN;","names":[]}