@crutchcrew/oxlint-plugin-import-access 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,1077 @@
+// src/rules/jsdoc.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+
+// src/core/checkImportability.ts
+import path5 from "node:path";
+import { Minimatch as Minimatch2 } from "minimatch";
+
+// src/utils/getAccessOfJsDocs.ts
+function getAccessOfJsDocs(tags, defaultImportability) {
+  for (const { name, text } of tags) {
+    if (name === "package" || name === "private" || name === "public") {
+      return name;
+    }
+    if (name === "access" && (text === "package" || text === "private" || text === "public")) {
+      return text;
+    }
+  }
+  return defaultImportability;
+}
+
+// src/utils/isInPackage.ts
+import path from "node:path";
+import { Minimatch } from "minimatch";
+var indexFileRegExp = /[/\\]index\.[cm]?[jt]sx?$/;
+
+class PackageBoundaries {
+  #options;
+  #patterns;
+  #packageDirCache = new Map;
+  constructor(options) {
+    this.#options = options;
+    const patterns = options.packageDirectory;
+    this.#patterns = patterns && patterns.length > 0 ? patterns.map((pattern) => {
+      const negated = pattern.startsWith("!");
+      return { negated, matcher: new Minimatch(negated ? pattern.slice(1) : pattern) };
+    }) : undefined;
+  }
+  #isPackageDirectory(dir, patterns) {
+    const dirName = path.basename(dir);
+    const relativePath = path.relative(this.#options.projectDirectory, dir);
+    let matched = false;
+    for (const { negated, matcher } of patterns) {
+      if (matcher.match(dirName) || matcher.match(relativePath)) {
+        if (negated) {
+          return false;
+        }
+        matched = true;
+      }
+    }
+    return matched;
+  }
+  packageDirectoryOf(filePath) {
+    const fileDir = path.dirname(filePath);
+    const patterns = this.#patterns;
+    if (patterns === undefined) {
+      return fileDir;
+    }
+    const cached = this.#packageDirCache.get(fileDir);
+    if (cached !== undefined) {
+      return cached;
+    }
+    let result = fileDir;
+    const { root } = path.parse(fileDir);
+    for (let dir = fileDir;dir !== root; dir = path.dirname(dir)) {
+      if (this.#isPackageDirectory(dir, patterns)) {
+        result = dir;
+        break;
+      }
+    }
+    this.#packageDirCache.set(fileDir, result);
+    return result;
+  }
+  isInPackage(importer, exporter) {
+    if (this.#options.indexLoophole) {
+      const match = indexFileRegExp.exec(exporter);
+      if (match) {
+        exporter = exporter.slice(0, -match[0].length);
+      }
+    }
+    const importerPackageDir = this.packageDirectoryOf(importer);
+    const exporterPackageDir = this.packageDirectoryOf(exporter);
+    if (importerPackageDir === exporterPackageDir) {
+      return true;
+    }
+    if (this.#options.filenameLoophole) {
+      const rel = path.relative(path.dirname(importer), path.dirname(exporter));
+      if (rel === path.basename(importer, path.extname(importer))) {
+        return true;
+      }
+    }
+    const rel = path.relative(exporterPackageDir, importerPackageDir);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+  }
+}
+
+// src/core/ambientModules.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import { parseSync as parseSync2 } from "oxc-parser";
+
+// src/core/exportTable.ts
+import { readFileSync, statSync } from "node:fs";
+import { parseSync } from "oxc-parser";
+
+// src/utils/jsdoc.ts
+var LF = 10;
+var CR = 13;
+function isWhitespace(code) {
+  return code === 32 || code === 9 || code === 11 || code === 12 || code === LF || code === CR || code === 160 || code === 65279 || code === 8232 || code === 8233;
+}
+function isLineBreak(code) {
+  return code === LF || code === CR || code === 8232 || code === 8233;
+}
+function lastCommentEndingBefore(comments, pos) {
+  let lo = 0;
+  let hi = comments.length - 1;
+  let found = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (comments[mid].end <= pos) {
+      found = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return found;
+}
+function findJsDocComments(sourceText, comments, nodeStart, includeSameLine = false) {
+  const attached = [];
+  let pos = nodeStart;
+  let index = lastCommentEndingBefore(comments, pos);
+  for (;; ) {
+    while (pos > 0 && isWhitespace(sourceText.charCodeAt(pos - 1))) {
+      pos--;
+    }
+    const comment = index >= 0 ? comments[index] : undefined;
+    if (comment === undefined || comment.end !== pos) {
+      break;
+    }
+    attached.push(comment);
+    pos = comment.start;
+    index--;
+  }
+  attached.reverse();
+  let firstCollectable = 0;
+  if (pos > 0 && !includeSameLine) {
+    firstCollectable = pos;
+    while (firstCollectable < nodeStart && !isLineBreak(sourceText.charCodeAt(firstCollectable))) {
+      firstCollectable++;
+    }
+  }
+  return attached.filter((comment) => comment.start >= firstCollectable && comment.type === "Block" && comment.value.startsWith("*") && comment.value !== "*");
+}
+var tagNameStart = /[\p{ID_Start}$_]/u;
+var tagNamePart = /[-\p{ID_Continue}$\u200c\u200d]/u;
+function parseJsDocTags(comment) {
+  const text = comment.value;
+  const tags = [];
+  let current;
+  let lineStart = true;
+  let afterWhitespace = true;
+  let inBackticks = false;
+  let pos = 1;
+  while (pos < text.length) {
+    const char = text[pos];
+    if (isLineBreak(char.charCodeAt(0))) {
+      if (current) {
+        current.text += `
+`;
+      }
+      lineStart = true;
+      afterWhitespace = true;
+      inBackticks = false;
+      pos++;
+      while (pos < text.length && (text[pos] === " " || text[pos] === "\t")) {
+        pos++;
+      }
+      if (text[pos] === "*") {
+        pos++;
+      }
+      continue;
+    }
+    if (char === "@" && !inBackticks && (lineStart || afterWhitespace) && tagNameStart.test(text[pos + 1] ?? "")) {
+      let end = pos + 2;
+      while (end < text.length && tagNamePart.test(text[end])) {
+        end++;
+      }
+      if (current) {
+        tags.push({ name: current.name, text: current.text.trim() });
+      }
+      current = { name: text.slice(pos + 1, end), text: "" };
+      pos = end;
+      lineStart = true;
+      continue;
+    }
+    if (char === "`") {
+      inBackticks = !inBackticks;
+    }
+    afterWhitespace = char === " " || char === "\t";
+    lineStart = false;
+    if (current) {
+      current.text += char;
+    }
+    pos++;
+  }
+  if (current) {
+    tags.push({ name: current.name, text: current.text.trim() });
+  }
+  return tags;
+}
+function jsDocTagsAt(sourceText, comments, nodeStart, includeSameLine = false) {
+  const blocks = findJsDocComments(sourceText, comments, nodeStart, includeSameLine);
+  const last = blocks.at(-1);
+  return {
+    own: last === undefined ? [] : parseJsDocTags(last),
+    all: blocks.flatMap(parseJsDocTags)
+  };
+}
+
+// src/core/exportTable.ts
+var EXPORT_EQUALS = "export=";
+var accessTagPattern = /@(?:package|private|access)(?![\p{ID_Continue}$-])/u;
+var starExportPattern = /\bexport(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*)*(?:type(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*)*)?\*/;
+var exportEqualsHint = /\bexport\s*=(?!=)/;
+function skipTrivia(text, pos) {
+  for (;; ) {
+    const code = text.charCodeAt(pos);
+    if (code === 32 || code === 9 || code === 10 || code === 13 || code === 11 || code === 12) {
+      pos++;
+    } else if (code === 47 && text.charCodeAt(pos + 1) === 47) {
+      const end = text.indexOf(`
+`, pos);
+      pos = end === -1 ? text.length : end;
+    } else if (code === 47 && text.charCodeAt(pos + 1) === 42) {
+      const end = text.indexOf("*/", pos + 2);
+      pos = end === -1 ? text.length : end + 2;
+    } else {
+      return pos;
+    }
+  }
+}
+var identifierPattern = /[\p{ID_Start}$_][\p{ID_Continue}$\u200c\u200d]*/uy;
+function wordAt(text, pos) {
+  identifierPattern.lastIndex = pos;
+  return identifierPattern.exec(text)?.[0] ?? "";
+}
+function declarationKind(text, pos) {
+  if (text.charCodeAt(pos) === 64) {
+    return "checked";
+  }
+  let word = wordAt(text, pos);
+  if (word === "declare") {
+    pos = skipTrivia(text, pos + word.length);
+    word = wordAt(text, pos);
+  }
+  switch (word) {
+    case "const":
+      return wordAt(text, skipTrivia(text, pos + word.length)) === "enum" ? "unchecked" : "variable";
+    case "let":
+    case "var":
+      return "variable";
+    case "function":
+    case "async":
+    case "class":
+    case "abstract":
+    case "type":
+    case "interface":
+      return "checked";
+    default:
+      return "unchecked";
+  }
+}
+function isSpecifierList(text, start) {
+  let pos = skipTrivia(text, start + "export".length);
+  if (text.startsWith("type", pos)) {
+    pos = skipTrivia(text, pos + "type".length);
+  }
+  return text.charCodeAt(pos) === 123;
+}
+function isInComment(comments, pos) {
+  let lo = 0;
+  let hi = comments.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const comment = comments[mid];
+    if (pos < comment.start) {
+      hi = mid - 1;
+    } else if (pos >= comment.end) {
+      lo = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function mayHaveDecorators(text, comments) {
+  for (let pos = text.indexOf("@");pos !== -1; pos = text.indexOf("@", pos + 1)) {
+    if (!isInComment(comments, pos)) {
+      return true;
+    }
+  }
+  return false;
+}
+var jsDocInitializers = new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "ParenthesizedExpression"
+]);
+function syntaxDetails(program) {
+  const decoratorStarts = new Map;
+  const exportLists = [];
+  const exportEquals = [];
+  const variables = new Map;
+  for (const statement of program.body) {
+    switch (statement.type) {
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration": {
+        const { declaration } = statement;
+        if (declaration?.type === "ClassDeclaration") {
+          const first = declaration.decorators[0];
+          if (first !== undefined && first.start < statement.start) {
+            decoratorStarts.set(statement.start, first.start);
+          }
+        } else if (declaration?.type === "VariableDeclaration") {
+          variables.set(statement.start, declaration.declarations.map(({ start, end, init }) => ({
+            start,
+            end,
+            initializer: init && jsDocInitializers.has(init.type) ? init.start : undefined
+          })));
+        } else if (declaration === null) {
+          exportLists.push([statement.start, statement.end]);
+        }
+        break;
+      }
+      case "TSExportAssignment":
+        exportEquals.push(statement.start);
+        break;
+    }
+  }
+  return { decoratorStarts, exportLists, exportEquals, variables };
+}
+function createModuleExports(fileName, text, comments, names, stars, details) {
+  const tagCache = new Map;
+  const tagsAt = (start, includeSameLine) => {
+    const key = `${start}:${includeSameLine}`;
+    let tags = tagCache.get(key);
+    if (tags === undefined) {
+      tags = jsDocTagsAt(text, comments, start, includeSameLine);
+      tagCache.set(key, tags);
+    }
+    return tags;
+  };
+  const ownTags = (entry) => {
+    const { own } = entry;
+    switch (own.kind) {
+      case "statement":
+        return tagsAt(entry.statementStart, false).own;
+      case "specifier":
+        return tagsAt(own.start, true).own;
+      case "none":
+        return [];
+    }
+    const statementTags = tagsAt(entry.statementStart, false);
+    const inner = comments.some((comment) => comment.start > entry.statementStart && comment.end <= own.statementEnd && comment.value.startsWith("*"));
+    if (!inner && statementTags.all.length === statementTags.own.length) {
+      return statementTags.own;
+    }
+    const declarators = details().variables.get(entry.statementStart);
+    const index = declarators.findIndex(({ start, end }) => start <= own.nameStart && own.nameStart < end);
+    const declarator = declarators[index];
+    return [
+      ...declarator.initializer === undefined ? [] : tagsAt(declarator.initializer, true).own,
+      ...tagsAt(declarator.start, true).own,
+      ...index === 0 ? statementTags.own : []
+    ];
+  };
+  return {
+    fileName,
+    names,
+    stars,
+    tagsOf(entries) {
+      const tags = entries.flatMap(ownTags);
+      tags.push(...tagsAt(entries[0].statementStart, false).all);
+      return tags;
+    }
+  };
+}
+function parseModuleExports(fileName, text, assumeAllPublic) {
+  if (assumeAllPublic && !accessTagPattern.test(text) && !starExportPattern.test(text)) {
+    return createModuleExports(fileName, text, [], undefined, []);
+  }
+  const result = parseSync(fileName, text);
+  const { comments } = result;
+  let cachedDetails;
+  const details = () => cachedDetails ??= syntaxDetails(result.program);
+  const decorated = mayHaveDecorators(text, comments);
+  const names = new Map;
+  const stars = [];
+  const add = (name, entry) => {
+    const list = names.get(name);
+    if (list) {
+      list.push(entry);
+    } else {
+      names.set(name, [entry]);
+    }
+  };
+  for (const statement of result.module.staticExports) {
+    for (const entry of statement.entries) {
+      const { exportName, importName, localName, moduleRequest } = entry;
+      if (importName.kind === "AllButDefault") {
+        stars.push(moduleRequest.value);
+        continue;
+      }
+      let statementStart = statement.start;
+      if (!text.startsWith("export", statementStart)) {
+        statementStart = details().exportLists.find(([start, end]) => start <= entry.start && entry.start < end)[0];
+      }
+      let checked = true;
+      let own = { kind: "statement" };
+      if (isSpecifierList(text, statementStart)) {
+        own = { kind: "specifier", start: entry.start };
+      } else if (importName.kind === "All") {
+        own = { kind: "none" };
+      } else if (exportName.kind === "Name" && localName.kind === "Name") {
+        const kind = declarationKind(text, entry.start);
+        checked = kind !== "unchecked";
+        if (kind === "variable") {
+          own = { kind: "variable", nameStart: exportName.start, statementEnd: statement.end };
+        }
+      }
+      add(exportName.kind === "Default" ? "default" : exportName.name, {
+        checked,
+        statementStart: decorated ? details().decoratorStarts.get(statementStart) ?? statementStart : statementStart,
+        own
+      });
+    }
+  }
+  if (exportEqualsHint.test(text)) {
+    for (const start of details().exportEquals) {
+      add(EXPORT_EQUALS, { checked: true, statementStart: start, own: { kind: "statement" } });
+    }
+  }
+  return createModuleExports(fileName, text, comments, names, stars, details);
+}
+
+class ExportTableCache {
+  #entries = new Map;
+  #generation = 0;
+  nextGeneration() {
+    this.#generation++;
+  }
+  get(fileName, assumeAllPublic) {
+    const cached = this.#entries.get(fileName);
+    const usable = cached !== undefined && (cached.exports.names !== undefined || assumeAllPublic) ? cached : undefined;
+    if (usable?.generation === this.#generation) {
+      return usable.exports;
+    }
+    let stats;
+    try {
+      stats = statSync(fileName);
+    } catch {
+      return;
+    }
+    if (usable !== undefined && usable.mtimeMs === stats.mtimeMs && usable.size === stats.size) {
+      usable.generation = this.#generation;
+      return usable.exports;
+    }
+    let text;
+    try {
+      text = readFileSync(fileName, "utf8");
+    } catch {
+      return;
+    }
+    const exports = parseModuleExports(fileName, text, assumeAllPublic);
+    this.#entries.set(fileName, {
+      mtimeMs: stats.mtimeMs,
+      size: stats.size,
+      generation: this.#generation,
+      exports
+    });
+    return exports;
+  }
+  clear() {
+    this.#entries.clear();
+  }
+}
+
+// src/core/ambientModules.ts
+var declarationFilePattern = /\.d\.[cm]?ts$/;
+var ambientModulePattern = /\bdeclare\s+module\s+["']/;
+function exportNameOf(name) {
+  return name.type === "Literal" ? name.value : name.name;
+}
+function isCheckedDeclaration(declaration) {
+  switch (declaration.type) {
+    case "VariableDeclaration":
+    case "FunctionDeclaration":
+    case "TSDeclareFunction":
+    case "ClassDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSInterfaceDeclaration":
+      return true;
+    default:
+      return false;
+  }
+}
+function declaredNames(declaration) {
+  if (declaration.type === "VariableDeclaration") {
+    const names = [];
+    const visit = (pattern) => {
+      const node = pattern;
+      switch (node.type) {
+        case "Identifier":
+          names.push(node["name"]);
+          break;
+        case "ObjectPattern":
+          for (const property of node["properties"]) {
+            visit(property);
+          }
+          break;
+        case "Property":
+          visit(node["value"]);
+          break;
+        case "ArrayPattern":
+          for (const element of node["elements"]) {
+            if (element !== null) {
+              visit(element);
+            }
+          }
+          break;
+        case "AssignmentPattern":
+          visit(node["left"]);
+          break;
+        case "RestElement":
+          visit(node["argument"]);
+          break;
+      }
+    };
+    for (const declarator of declaration.declarations) {
+      visit(declarator.id);
+    }
+    return names;
+  }
+  const id = declaration.id;
+  return id?.type === "Identifier" && id.name !== undefined ? [id.name] : [];
+}
+function moduleBlockExports(fileName, text, comments, body) {
+  const names = new Map;
+  const stars = [];
+  const add = (name, entry) => {
+    const list = names.get(name);
+    if (list) {
+      list.push(entry);
+    } else {
+      names.set(name, [entry]);
+    }
+  };
+  for (const statement of body) {
+    switch (statement.type) {
+      case "ExportNamedDeclaration": {
+        const { declaration } = statement;
+        if (declaration) {
+          const checked = isCheckedDeclaration(declaration);
+          for (const name of declaredNames(declaration)) {
+            add(name, { checked, statementStart: statement.start, own: { kind: "statement" } });
+          }
+        }
+        for (const specifier of statement.specifiers) {
+          add(exportNameOf(specifier.exported), {
+            checked: true,
+            statementStart: statement.start,
+            own: { kind: "specifier", start: specifier.start }
+          });
+        }
+        break;
+      }
+      case "ExportDefaultDeclaration":
+        add("default", {
+          checked: true,
+          statementStart: statement.start,
+          own: { kind: "statement" }
+        });
+        break;
+      case "TSExportAssignment":
+        add(EXPORT_EQUALS, {
+          checked: true,
+          statementStart: statement.start,
+          own: { kind: "statement" }
+        });
+        break;
+      case "ExportAllDeclaration":
+        if (statement.exported) {
+          add(exportNameOf(statement.exported), {
+            checked: true,
+            statementStart: statement.start,
+            own: { kind: "none" }
+          });
+        } else {
+          stars.push(statement.source.value);
+        }
+        break;
+    }
+  }
+  return createModuleExports(fileName, text, comments, names, stars);
+}
+function parseAmbientModules(fileName, text) {
+  const modules = new Map;
+  const result = parseSync2(fileName, text);
+  if (result.module.hasModuleSyntax) {
+    return modules;
+  }
+  for (const statement of result.program.body) {
+    if (statement.type === "TSModuleDeclaration" && statement.id.type === "Literal" && statement.body?.type === "TSModuleBlock") {
+      const name = statement.id.value;
+      if (!modules.has(name)) {
+        modules.set(name, moduleBlockExports(fileName, text, result.comments, statement.body.body));
+      }
+    }
+  }
+  return modules;
+}
+function* declarationFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      continue;
+    }
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* declarationFiles(fullPath);
+    } else if (declarationFilePattern.test(entry.name)) {
+      yield fullPath;
+    }
+  }
+}
+
+class AmbientModuleIndex {
+  #roots = new Map;
+  #indexOf(rootDir) {
+    let index = this.#roots.get(rootDir);
+    if (index === undefined) {
+      index = { exact: new Map, patterns: [] };
+      for (const fileName of declarationFiles(rootDir)) {
+        let text;
+        try {
+          text = readFileSync2(fileName, "utf8");
+        } catch {
+          continue;
+        }
+        if (!ambientModulePattern.test(text)) {
+          continue;
+        }
+        for (const [name, exports] of parseAmbientModules(fileName, text)) {
+          const star = name.indexOf("*");
+          if (star === -1) {
+            if (!index.exact.has(name)) {
+              index.exact.set(name, exports);
+            }
+          } else {
+            index.patterns.push({
+              prefix: name.slice(0, star),
+              suffix: name.slice(star + 1),
+              exports
+            });
+          }
+        }
+      }
+      this.#roots.set(rootDir, index);
+    }
+    return index;
+  }
+  exact(rootDir, specifier) {
+    return this.#indexOf(rootDir).exact.get(specifier);
+  }
+  pattern(rootDir, specifier) {
+    let best;
+    for (const pattern of this.#indexOf(rootDir).patterns) {
+      if (specifier.length >= pattern.prefix.length + pattern.suffix.length && specifier.startsWith(pattern.prefix) && specifier.endsWith(pattern.suffix) && (best === undefined || pattern.prefix.length > best.prefix.length)) {
+        best = pattern;
+      }
+    }
+    return best?.exports;
+  }
+  clear() {
+    this.#roots.clear();
+  }
+}
+
+// src/core/lookupPackageJson.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path3 from "node:path";
+var packageNameCache = new Map;
+function readPackageName(packageJsonPath) {
+  let text;
+  try {
+    text = readFileSync3(packageJsonPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  let packageJson;
+  try {
+    packageJson = JSON.parse(text);
+  } catch {
+    return;
+  }
+  const name = packageJson?.name;
+  return typeof name === "string" ? name : null;
+}
+function lookupPackageName(file) {
+  const visited = [];
+  let result = null;
+  const { root } = path3.parse(path3.resolve(file));
+  for (let dir = path3.dirname(path3.resolve(file));dir !== root; dir = path3.dirname(dir)) {
+    const cached = packageNameCache.get(dir);
+    if (cached !== undefined) {
+      result = cached;
+      break;
+    }
+    visited.push(dir);
+    const name = readPackageName(path3.join(dir, "package.json"));
+    if (name !== undefined) {
+      result = name;
+      break;
+    }
+  }
+  for (const dir of visited) {
+    packageNameCache.set(dir, result);
+  }
+  return result;
+}
+
+// src/core/resolveModule.ts
+import { realpathSync } from "node:fs";
+import path4 from "node:path";
+import { ResolverFactory } from "oxc-resolver";
+var EXTERNAL = { kind: "external" };
+var UNRESOLVED = { kind: "unresolved" };
+var sourceFilePattern = /\.(?:[cm]?[jt]sx?|d\.[cm]?ts)$/;
+var jsonFilePattern = /\.json$/;
+var nodeModulesPattern = /[/\\]node_modules[/\\]/;
+var relativeSpecifier = /^\.{1,2}(?:[/\\]|$)/;
+var directorySpecifier = /(?:^|[/\\])\.{0,2}$/;
+
+class ModuleResolver {
+  #resolver = new ResolverFactory({
+    tsconfig: "auto",
+    builtinModules: true,
+    symlinks: false,
+    conditionNames: ["types", "import", "require", "node", "default"],
+    mainFields: ["types", "typings", "module", "main"],
+    extensions: [
+      ".ts",
+      ".tsx",
+      ".d.ts",
+      ".mts",
+      ".d.mts",
+      ".cts",
+      ".d.cts",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".json"
+    ],
+    extensionAlias: {
+      ".js": [".ts", ".tsx", ".d.ts", ".js", ".jsx"],
+      ".jsx": [".tsx", ".d.ts", ".jsx"],
+      ".mjs": [".mts", ".d.mts", ".mjs"],
+      ".cjs": [".cts", ".d.cts", ".cjs"]
+    }
+  });
+  #byDirectory = new Map;
+  #byTarget = new Map;
+  resolve(importerFileName, specifier) {
+    const importerDir = path4.dirname(importerFileName);
+    const directoryKey = `${importerDir}\x00${specifier}`;
+    let resolution = this.#byDirectory.get(directoryKey);
+    if (resolution === undefined) {
+      if (relativeSpecifier.test(specifier)) {
+        const target = path4.resolve(importerDir, specifier) + (directorySpecifier.test(specifier) ? path4.sep : "");
+        resolution = this.#byTarget.get(target);
+        if (resolution === undefined) {
+          resolution = this.#resolveUncached(importerFileName, specifier);
+          this.#byTarget.set(target, resolution);
+        }
+      } else {
+        resolution = this.#resolveUncached(importerFileName, specifier);
+      }
+      this.#byDirectory.set(directoryKey, resolution);
+    }
+    return resolution;
+  }
+  #resolveUncached(importerFileName, specifier) {
+    const result = this.#resolver.resolveFileSync(importerFileName, specifier);
+    if (result.builtin !== undefined) {
+      return EXTERNAL;
+    }
+    const resolved = result.path;
+    if (resolved === undefined) {
+      return UNRESOLVED;
+    }
+    if (jsonFilePattern.test(resolved)) {
+      return EXTERNAL;
+    }
+    if (!sourceFilePattern.test(resolved)) {
+      return UNRESOLVED;
+    }
+    if (nodeModulesPattern.test(resolved)) {
+      return EXTERNAL;
+    }
+    return { kind: "internal", fileName: realpathSync.native(resolved) };
+  }
+  clear() {
+    this.#byDirectory.clear();
+    this.#byTarget.clear();
+    this.#resolver.clearCache();
+  }
+}
+
+// src/core/checkImportability.ts
+var possibleSubpathImportFromPackage = /^(?![./\\])([^/\\]*)(?:$|[/\\][^/\\])/;
+var relativeOrAbsolute = /^(?:\.{1,2}(?:[/\\]|$)|[/\\]|[a-zA-Z]:[/\\])/;
+
+class ImportabilityChecker {
+  resolver = new ModuleResolver;
+  exportTables = new ExportTableCache;
+  ambientModules = new AmbientModuleIndex;
+  #found = new WeakMap;
+  findExport(module, name) {
+    let byName = this.#found.get(module);
+    if (byName === undefined) {
+      byName = new Map;
+      this.#found.set(module, byName);
+    }
+    let found = byName.get(name);
+    if (found === undefined) {
+      found = this.#findExport(module, name, new Set) ?? null;
+      byName.set(name, found);
+    }
+    return found ?? undefined;
+  }
+  #findExport(module, name, visited) {
+    if (module.names === undefined) {
+      return;
+    }
+    const entries = module.names.get(name);
+    if (entries !== undefined) {
+      return { module, name, entries };
+    }
+    if (name === "default") {
+      const exportEquals = module.names.get(EXPORT_EQUALS);
+      return exportEquals && { module, name: EXPORT_EQUALS, entries: exportEquals };
+    }
+    visited.add(module.fileName);
+    for (const request of module.stars) {
+      const target = this.resolver.resolve(module.fileName, request);
+      if (target.kind !== "internal" || visited.has(target.fileName)) {
+        continue;
+      }
+      const targetModule = this.exportTables.get(target.fileName, false);
+      const found = targetModule && this.#findExport(targetModule, name, visited);
+      if (found !== undefined) {
+        return found;
+      }
+    }
+    return;
+  }
+  targetModule(importerFileName, specifier, projectDirectory, assumeAllPublic) {
+    if (!relativeOrAbsolute.test(specifier)) {
+      const ambient = this.ambientModules.exact(projectDirectory, specifier);
+      if (ambient !== undefined) {
+        return ambient;
+      }
+    }
+    const resolution = this.resolver.resolve(importerFileName, specifier);
+    if (resolution.kind === "internal") {
+      return this.exportTables.get(resolution.fileName, assumeAllPublic);
+    }
+    return resolution.kind === "unresolved" ? this.ambientModules.pattern(projectDirectory, specifier) : undefined;
+  }
+  #watching;
+  #lintedFiles = new Set;
+  constructor(watching = process.argv.includes("--lsp")) {
+    this.#watching = watching;
+  }
+  nextFile(fileName) {
+    if (!this.#watching) {
+      if (!this.#lintedFiles.has(fileName)) {
+        this.#lintedFiles.add(fileName);
+        return;
+      }
+      this.#watching = true;
+      this.#lintedFiles.clear();
+    }
+    this.exportTables.nextGeneration();
+    this.resolver.clear();
+    this.#found = new WeakMap;
+  }
+  clear() {
+    this.#found = new WeakMap;
+    this.resolver.clear();
+    this.exportTables.clear();
+    this.ambientModules.clear();
+  }
+}
+
+class ImportabilityPolicy {
+  options;
+  #exclude;
+  #boundaries;
+  constructor(options) {
+    this.options = options;
+    this.#exclude = options.excludeSourcePatterns.map((pattern) => new Minimatch2(pattern, { dot: true }));
+    this.#boundaries = new PackageBoundaries(options);
+  }
+  #isExcluded(exporterFileName) {
+    if (this.#exclude.length === 0) {
+      return false;
+    }
+    const relativePath = path5.relative(this.options.projectDirectory, exporterFileName);
+    return this.#exclude.some((matcher) => matcher.match(relativePath));
+  }
+  #isSelfReference(importerFileName, specifier) {
+    if (this.options.treatSelfReferenceAs !== "external" || !possibleSubpathImportFromPackage.test(specifier)) {
+      return false;
+    }
+    const packageName = lookupPackageName(importerFileName);
+    return packageName !== null && (specifier === packageName || specifier.startsWith(`${packageName}/`));
+  }
+  check(checker, importerFileName, specifier, name) {
+    const { defaultImportability, projectDirectory } = this.options;
+    const assumeAllPublic = defaultImportability === "public";
+    const module = checker.targetModule(importerFileName, specifier, projectDirectory, assumeAllPublic);
+    const found = module && checker.findExport(module, name);
+    if (found === undefined || !found.entries[0].checked) {
+      return;
+    }
+    const exporterFileName = found.module.fileName;
+    if (this.#isExcluded(exporterFileName) || this.#isSelfReference(importerFileName, specifier)) {
+      return;
+    }
+    const access = getAccessOfJsDocs(found.module.tagsOf(found.entries), defaultImportability);
+    if (access === "public" || access === "package" && this.#boundaries.isInPackage(importerFileName, exporterFileName)) {
+      return;
+    }
+    return { access, identifier: found.name };
+  }
+}
+
+// src/utils/options.ts
+var defaultOptions = {
+  indexLoophole: true,
+  filenameLoophole: false,
+  defaultImportability: "package",
+  treatSelfReferenceAs: "external",
+  excludeSourcePatterns: []
+};
+function normalizeOptions(options, projectDirectory) {
+  return {
+    indexLoophole: options?.indexLoophole ?? defaultOptions.indexLoophole,
+    filenameLoophole: options?.filenameLoophole ?? defaultOptions.filenameLoophole,
+    defaultImportability: options?.defaultImportability ?? defaultOptions.defaultImportability,
+    treatSelfReferenceAs: options?.treatSelfReferenceAs ?? defaultOptions.treatSelfReferenceAs,
+    excludeSourcePatterns: options?.excludeSourcePatterns ?? defaultOptions.excludeSourcePatterns,
+    packageDirectory: options?.packageDirectory,
+    projectDirectory
+  };
+}
+
+// src/rules/jsdoc.ts
+var checker = new ImportabilityChecker;
+var policies = new Map;
+function policyFor(options, cwd) {
+  const key = `${cwd}\x00${JSON.stringify(options ?? {})}`;
+  let policy = policies.get(key);
+  if (policy === undefined) {
+    policy = new ImportabilityPolicy(normalizeOptions(options, cwd));
+    policies.set(key, policy);
+  }
+  return policy;
+}
+function realFileName(fileName) {
+  try {
+    return realpathSync2.native(fileName);
+  } catch {
+    return fileName;
+  }
+}
+function nameOf(node) {
+  return node.type === "Literal" ? node.value : node.name;
+}
+var rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prohibit importing package-private and private exports.",
+      url: "https://github.com/crutchcrew/oxlint-plugin-import-access/blob/main/docs/rule-jsdoc.md"
+    },
+    messages: {
+      package: "Cannot import a package-private export '{{ identifier }}'",
+      "package:reexport": "Cannot re-export a package-private export '{{ identifier }}'",
+      private: "Cannot import a private export '{{ identifier }}'",
+      "private:reexport": "Cannot re-export a private export '{{ identifier }}'"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          indexLoophole: { type: "boolean" },
+          filenameLoophole: { type: "boolean" },
+          defaultImportability: { type: "string", enum: ["public", "package", "private"] },
+          treatSelfReferenceAs: { type: "string", enum: ["external", "internal"] },
+          excludeSourcePatterns: { type: "array", items: { type: "string" } },
+          packageDirectory: { type: "array", items: { type: "string" } }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  createOnce(context) {
+    let policy;
+    let importer;
+    const check = (node, specifier, name, reexport) => {
+      const violation = policy.check(checker, importer, specifier, name);
+      if (violation !== undefined) {
+        context.report({
+          node,
+          messageId: reexport ? `${violation.access}:reexport` : violation.access,
+          data: { identifier: violation.identifier }
+        });
+      }
+    };
+    return {
+      before() {
+        if (!context.sourceCode.text.includes("from")) {
+          return false;
+        }
+        policy = policyFor(context.options[0], context.cwd);
+        importer = realFileName(context.filename);
+        checker.nextFile(importer);
+        return true;
+      },
+      ImportSpecifier(node) {
+        check(node, node.parent.source.value, nameOf(node.imported), false);
+      },
+      ImportDefaultSpecifier(node) {
+        check(node, node.parent.source.value, "default", false);
+      },
+      ExportSpecifier(node) {
+        const { source } = node.parent;
+        if (source !== null) {
+          check(node, source.value, nameOf(node.local), true);
+        }
+      }
+    };
+  }
+};
+var jsdoc_default = rule;
+
+// src/index.ts
+var plugin = {
+  meta: { name: "import-access" },
+  rules: { jsdoc: jsdoc_default }
+};
+var src_default = plugin;
+export {
+  src_default as default
+};