@storm-software/eslint 0.170.147 → 0.170.148

package/dist/src-PMVM4MJ3.js

@@ -0,0 +1,887 @@
+import { GLOB_EXCLUDE } from './chunk-23MHL5A5.js';
+import { init_esm_shims } from './chunk-V2FABXKB.js';
+import parserJsonc from 'jsonc-eslint-parser';
+import defu from 'defu';
+import fs from 'node:fs';
+import process from 'node:process';
+import { findUpSync } from 'find-up-simple';
+import { normalize, resolve, dirname } from 'pathe';
+import { globSync } from 'tinyglobby';
+
+// ../eslint-plugin-bun/src/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-bun/src/configs/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-bun/src/configs/recommended.ts
+init_esm_shims();
+
+// ../eslint-plugin-bun/src/plugin.ts
+init_esm_shims();
+
+// ../eslint-plugin-bun/package.json
+var package_default = {
+  version: "0.0.1"};
+
+// ../eslint-plugin-bun/src/rules/json-enforce-catalog.ts
+init_esm_shims();
+
+// ../eslint-plugin-bun/src/helpers/create-rule.ts
+init_esm_shims();
+function RuleCreator(urlCreator) {
+  return function createNamedRule({
+    name,
+    meta,
+    ...rule
+  }) {
+    return createRuleInfo({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name)
+        }
+      },
+      ...rule
+    });
+  };
+}
+function createRuleInfo({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: ((context) => {
+      const optionsWithDefault = context.options.map((options, index) => {
+        return defu(defaultOptions?.[index] ?? {}, options);
+      });
+      return create(context, optionsWithDefault);
+    }),
+    defaultOptions: defaultOptions ?? {},
+    meta
+  };
+}
+var createRule = RuleCreator(
+  (ruleName) => `https://docs.stormsoftware.com/projects/storm-ops/eslint-plugin-bun/rules/${ruleName}.md`
+);
+
+// ../eslint-plugin-bun/src/helpers/bun-workspace.ts
+init_esm_shims();
+function isWorkspaceObject(workspaces) {
+  return Boolean(workspaces) && typeof workspaces === "object" && !Array.isArray(workspaces);
+}
+function detectCatalogRoot(data) {
+  if (data.catalog || data.catalogs) {
+    return "top";
+  }
+  if (isWorkspaceObject(data.workspaces) && (data.workspaces.catalog || data.workspaces.catalogs)) {
+    return "workspaces";
+  }
+  return isWorkspaceObject(data.workspaces) ? "workspaces" : "top";
+}
+function normalizeCatalogName(name) {
+  return name.replace(/\^/g, "h").replace(/~/g, "t").replace(/\./g, "_").replace(/</g, "l").replace(/>/g, "g").replace(/=/g, "e").replace(/\*/g, "s").replace(/@/g, "a").replace(/\|/g, "p").replace(/&/g, "n").replace(/-/g, "m").replace(/\+/g, "u").replace(/\s/g, "_");
+}
+function sortObjectKeys(input) {
+  return Object.fromEntries(
+    Object.entries(input).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function isWorkspaceRootPackageJson(data) {
+  return Boolean(
+    data.workspaces || data.catalog || data.catalogs
+  );
+}
+function readBunWorkspace(cwd = process.cwd()) {
+  const filepath = findUpSync("package.json", {
+    cwd,
+    type: "file"
+  });
+  if (!filepath) {
+    throw new Error("package.json not found");
+  }
+  let current = filepath;
+  let content = fs.readFileSync(current, "utf8");
+  let data = JSON.parse(content);
+  while (!isWorkspaceRootPackageJson(data)) {
+    const searchFrom = dirname(dirname(current));
+    const next = findUpSync("package.json", {
+      cwd: searchFrom,
+      type: "file"
+    });
+    if (!next || normalize(next) === normalize(current)) {
+      break;
+    }
+    current = next;
+    content = fs.readFileSync(current, "utf8");
+    data = JSON.parse(content);
+  }
+  if (!isWorkspaceRootPackageJson(data)) {
+    throw new Error(
+      "Bun workspace root package.json with workspaces/catalog not found"
+    );
+  }
+  let hasChanged = false;
+  let queueTimer;
+  const queue = [];
+  let catalogRoot = detectCatalogRoot(data);
+  const write = () => {
+    if (!fs.existsSync(current)) {
+      return;
+    }
+    fs.writeFileSync(current, `${JSON.stringify(data, null, 2)}
+`);
+  };
+  const clearQueue = () => {
+    if (queueTimer != null) {
+      clearTimeout(queueTimer);
+      queueTimer = void 0;
+    }
+    queue.length = 0;
+  };
+  const getCatalogContainer = () => {
+    if (catalogRoot === "workspaces") {
+      if (!isWorkspaceObject(data.workspaces)) {
+        data.workspaces = {
+          packages: Array.isArray(data.workspaces) ? data.workspaces : [],
+          catalog: {},
+          catalogs: {}
+        };
+      }
+      return data.workspaces;
+    }
+    return data;
+  };
+  const getCatalogData = () => {
+    const container = getCatalogContainer();
+    return {
+      catalog: container.catalog,
+      catalogs: container.catalogs
+    };
+  };
+  const setPackage = (catalogName, packageName, specifier) => {
+    const container = getCatalogContainer();
+    if (catalogName === "default") {
+      container.catalog ??= {};
+      if (container.catalog[packageName] !== specifier) {
+        container.catalog[packageName] = specifier;
+        container.catalog = sortObjectKeys(container.catalog);
+        hasChanged = true;
+      }
+      return;
+    }
+    container.catalogs ??= {};
+    container.catalogs[catalogName] ??= {};
+    if (container.catalogs[catalogName][packageName] !== specifier) {
+      container.catalogs[catalogName][packageName] = specifier;
+      container.catalogs[catalogName] = sortObjectKeys(
+        container.catalogs[catalogName]
+      );
+      container.catalogs = sortObjectKeys(container.catalogs);
+      hasChanged = true;
+    }
+  };
+  const hasSpecifierConflicts = (catalogName, packageName, specifier) => {
+    const { catalog, catalogs } = getCatalogData();
+    const existingSpecifier = catalogName === "default" ? catalog?.[packageName] : catalogs?.[catalogName]?.[packageName];
+    if (existingSpecifier === specifier) {
+      return {
+        conflicts: false,
+        newCatalogName: catalogName,
+        existingSpecifier
+      };
+    }
+    if (existingSpecifier) {
+      const versionSuffix = normalizeCatalogName(specifier);
+      const newCatalogName = catalogName === "default" ? `conflicts_${packageName}_${versionSuffix}` : `conflicts_${catalogName}_${versionSuffix}`;
+      return {
+        conflicts: true,
+        existingSpecifier,
+        newCatalogName
+      };
+    }
+    return {
+      conflicts: false,
+      newCatalogName: catalogName
+    };
+  };
+  const getPackageCatalogs = (packageName) => {
+    const found = [];
+    const { catalog, catalogs } = getCatalogData();
+    if (catalogs) {
+      for (const name of Object.keys(catalogs)) {
+        if (catalogs[name]?.[packageName]) {
+          found.push(name);
+        }
+      }
+    }
+    if (catalog?.[packageName]) {
+      found.push("default");
+    }
+    return found;
+  };
+  const workspace2 = {
+    filepath: current,
+    setContent(newContent) {
+      content = newContent;
+      data = JSON.parse(newContent);
+      catalogRoot = detectCatalogRoot(data);
+      hasChanged = false;
+    },
+    hasChanged: () => hasChanged,
+    hasQueue: () => queueTimer != null,
+    clearQueue,
+    queueChange(fn, order) {
+      if (order === "pre") {
+        queue.unshift(fn);
+      } else {
+        queue.push(fn);
+      }
+      if (queueTimer != null) {
+        clearTimeout(queueTimer);
+      }
+      queueTimer = setTimeout(() => {
+        queueTimer = void 0;
+        const clone = [...queue];
+        queue.length = 0;
+        for (const queued of clone) {
+          queued(workspace2);
+        }
+        if (hasChanged) {
+          write();
+        }
+      }, 1e3);
+    },
+    toJSON: () => data,
+    toString: () => `${JSON.stringify(data, null, 2)}
+`,
+    setPackage,
+    setPackageNoConflicts(catalogName, packageName, specifier) {
+      const { newCatalogName } = hasSpecifierConflicts(
+        catalogName,
+        packageName,
+        specifier
+      );
+      setPackage(newCatalogName, packageName, specifier);
+    },
+    getPackageCatalogs,
+    hasSpecifierConflicts,
+    getCatalogData,
+    getWorkspacePackagePatterns() {
+      if (Array.isArray(data.workspaces)) {
+        return data.workspaces;
+      }
+      if (isWorkspaceObject(data.workspaces) && data.workspaces.packages) {
+        return data.workspaces.packages;
+      }
+      return [];
+    }
+  };
+  return workspace2;
+}
+var WORKSPACE_CACHE_TIME = 1e4;
+var workspaceLastRead;
+var workspace;
+function getBunWorkspace(cwd = process.cwd()) {
+  if (workspaceLastRead && workspace && !workspace.hasQueue() && Date.now() - workspaceLastRead > WORKSPACE_CACHE_TIME) {
+    workspace = void 0;
+  }
+  if (!workspace) {
+    workspace = readBunWorkspace(cwd);
+    workspaceLastRead = Date.now();
+  }
+  return workspace;
+}
+function isRootWorkspacePackageJson(filename, cwd = process.cwd()) {
+  try {
+    const root = getBunWorkspace(cwd);
+    return normalize(root.filepath) === normalize(filename);
+  } catch {
+    return false;
+  }
+}
+function collectWorkspacePackageJsonPaths(workspaceRoot) {
+  const root = resolve(dirname(workspaceRoot.filepath));
+  const patterns = workspaceRoot.getWorkspacePackagePatterns();
+  const dirs = patterns.length ? globSync(patterns, {
+    cwd: root,
+    dot: false,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**"
+    ],
+    absolute: true,
+    expandDirectories: false,
+    onlyDirectories: true
+  }) : [];
+  dirs.push(root);
+  return dirs.map((dir) => resolve(dir, "package.json")).filter((path) => fs.existsSync(path)).sort();
+}
+
+// ../eslint-plugin-bun/src/helpers/iterate-dependencies.ts
+init_esm_shims();
+function getPackageJsonRootNode(context) {
+  if (!context.filename.endsWith("package.json")) {
+    return void 0;
+  }
+  const ast = context.sourceCode.ast;
+  const root = ast.body[0];
+  if (root?.expression?.type === "JSONObjectExpression") {
+    return root.expression;
+  }
+  return void 0;
+}
+function* iterateDependencies(context, fields) {
+  const root = getPackageJsonRootNode(context);
+  if (!root) {
+    return;
+  }
+  for (const fieldName of fields) {
+    const path = fieldName.split(".");
+    let node = root;
+    for (const segment of path) {
+      const item = node.properties?.find(
+        (property) => property.key.type === "JSONLiteral" && property.key.value === segment
+      );
+      if (!item?.value || item.value.type !== "JSONObjectExpression") {
+        node = void 0;
+        break;
+      }
+      node = item.value;
+    }
+    if (!node || node === root || !node.properties) {
+      continue;
+    }
+    for (const property of node.properties) {
+      if (property.value.type !== "JSONLiteral" || property.key.type !== "JSONLiteral") {
+        continue;
+      }
+      if (typeof property.value.value !== "string") {
+        continue;
+      }
+      yield {
+        packageName: String(property.key.value),
+        specifier: String(property.value.value),
+        property
+      };
+    }
+  }
+}
+function getObjectPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (!current || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+    if (!current) {
+      return void 0;
+    }
+  }
+  return current;
+}
+
+// ../eslint-plugin-bun/src/rules/json-enforce-catalog.ts
+var RULE_NAME = "json-enforce-catalog";
+var DEFAULT_FIELDS = ["dependencies", "devDependencies"];
+var IGNORED_DEPENDENCIES = ["typescript"];
+var json_enforce_catalog_default = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "layout",
+    docs: {
+      description: 'Enforce using "catalog:" in `package.json` and write versions to the Bun workspace root catalog'
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedProtocols: {
+            type: "array",
+            description: "Allowed protocols in specifier to not be converted to catalog",
+            items: { type: "string" }
+          },
+          autofix: {
+            type: "boolean",
+            description: "Whether to autofix the linting error",
+            default: true
+          },
+          defaultCatalog: {
+            type: "string",
+            description: "Default catalog to use when moving version to catalog with autofix"
+          },
+          reuseExistingCatalog: {
+            type: "boolean",
+            description: "Whether to reuse existing catalog when moving version to catalog with autofix",
+            default: true
+          },
+          conflicts: {
+            type: "string",
+            description: "Strategy to handle conflicts when adding packages to catalogs",
+            enum: ["new-catalog", "overrides", "error"],
+            default: "new-catalog"
+          },
+          fields: {
+            type: "array",
+            description: "Fields to check for catalog",
+            items: { type: "string" },
+            default: DEFAULT_FIELDS
+          },
+          ignore: {
+            type: "array",
+            description: "A list of dependencies to ignore",
+            items: { type: "string" },
+            default: IGNORED_DEPENDENCIES
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      expectCatalog: 'Expect to use catalog instead of plain specifier, got "{{specifier}}" for package "{{packageName}}".'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options]) {
+    const {
+      allowedProtocols = ["workspace", "link", "file"],
+      defaultCatalog = "default",
+      autofix = true,
+      reuseExistingCatalog = true,
+      conflicts = "new-catalog",
+      fields = DEFAULT_FIELDS,
+      ignore = IGNORED_DEPENDENCIES
+    } = options || {};
+    for (const { packageName, specifier, property } of iterateDependencies(
+      context,
+      fields
+    )) {
+      if (ignore?.some((name) => name === packageName)) {
+        continue;
+      }
+      if (specifier.startsWith("catalog:")) {
+        continue;
+      }
+      if (allowedProtocols?.some((protocol) => specifier.startsWith(protocol))) {
+        continue;
+      }
+      let workspace2;
+      try {
+        workspace2 = getBunWorkspace();
+      } catch {
+        return {};
+      }
+      let targetCatalog = reuseExistingCatalog ? workspace2.getPackageCatalogs(packageName)[0] || defaultCatalog : defaultCatalog;
+      const resolvedConflicts = workspace2.hasSpecifierConflicts(
+        targetCatalog,
+        packageName,
+        specifier
+      );
+      let shouldFix = autofix;
+      if (conflicts === "error" && resolvedConflicts.conflicts) {
+        shouldFix = false;
+      }
+      if (conflicts === "new-catalog" && resolvedConflicts.conflicts) {
+        targetCatalog = resolvedConflicts.newCatalogName;
+      }
+      context.report({
+        node: property.value,
+        messageId: "expectCatalog",
+        data: {
+          specifier,
+          packageName
+        },
+        fix: shouldFix ? (fixer) => {
+          workspace2.queueChange(() => {
+            workspace2.setPackage(targetCatalog, packageName, specifier);
+          });
+          return fixer.replaceText(
+            property.value,
+            targetCatalog === "default" ? JSON.stringify("catalog:") : JSON.stringify(`catalog:${targetCatalog}`)
+          );
+        } : void 0
+      });
+    }
+    return {};
+  }
+});
+
+// ../eslint-plugin-bun/src/rules/json-no-duplicate-catalog-item.ts
+init_esm_shims();
+var RULE_NAME2 = "json-no-duplicate-catalog-item";
+function getProperty(node, key) {
+  return node?.properties?.find(
+    (property) => property.key.type === "JSONLiteral" && property.key.value === key
+  );
+}
+var json_no_duplicate_catalog_item_default = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow duplicate catalog items in the Bun workspace root `package.json`"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allow: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      duplicateCatalogItem: 'Catalog item "{{name}}" is already defined in the "{{existingCatalog}}" catalog. You may want to remove one of them.'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    if (!isRootWorkspacePackageJson(context.filename)) {
+      return {};
+    }
+    let workspace2;
+    try {
+      workspace2 = getBunWorkspace();
+    } catch {
+      return {};
+    }
+    if (workspace2.hasChanged() || workspace2.hasQueue()) {
+      return {};
+    }
+    workspace2.setContent(context.sourceCode.text);
+    const root = getPackageJsonRootNode(context);
+    if (!root) {
+      return {};
+    }
+    const { allow = [] } = options;
+    const topCatalog = getProperty(root, "catalog");
+    const topCatalogs = getProperty(root, "catalogs");
+    const workspaces = getProperty(root, "workspaces");
+    const workspacesCatalog = workspaces?.value?.type === "JSONObjectExpression" ? getProperty(workspaces.value, "catalog") : void 0;
+    const workspacesCatalogs = workspaces?.value?.type === "JSONObjectExpression" ? getProperty(workspaces.value, "catalogs") : void 0;
+    const catalogNode = topCatalog ?? workspacesCatalog;
+    const catalogsNode = topCatalogs ?? workspacesCatalogs;
+    const exists = /* @__PURE__ */ new Map();
+    const catalogEntries = [];
+    if (catalogNode?.value?.type === "JSONObjectExpression") {
+      for (const property of catalogNode.value.properties || []) {
+        catalogEntries.push({ catalogName: "default", property });
+      }
+    }
+    if (catalogsNode?.value?.type === "JSONObjectExpression") {
+      for (const named of catalogsNode.value.properties || []) {
+        if (named.value.type !== "JSONObjectExpression") {
+          continue;
+        }
+        const catalogName = String(named.key.value);
+        for (const property of named.value.properties || []) {
+          catalogEntries.push({ catalogName, property });
+        }
+      }
+    }
+    for (const { catalogName, property } of catalogEntries) {
+      const key = String(property.key.value);
+      if (allow.includes(key)) {
+        continue;
+      }
+      if (exists.has(key)) {
+        context.report({
+          node: property.value,
+          messageId: "duplicateCatalogItem",
+          data: {
+            name: key,
+            currentCatalog: catalogName,
+            existingCatalog: exists.get(key)
+          }
+        });
+      } else {
+        exists.set(key, catalogName);
+      }
+    }
+    return {};
+  }
+});
+
+// ../eslint-plugin-bun/src/rules/json-no-unused-catalog-item.ts
+init_esm_shims();
+var RULE_NAME3 = "json-no-unused-catalog-item";
+var FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+  "overrides",
+  "resolutions"
+];
+function getProperty2(node, key) {
+  return node?.properties?.find(
+    (property) => property.key.type === "JSONLiteral" && property.key.value === key
+  );
+}
+var json_no_unused_catalog_item_default = createRule({
+  name: RULE_NAME3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused catalog items in the Bun workspace root `package.json`"
+    },
+    schema: [],
+    messages: {
+      unusedCatalogItem: 'Catalog item "{{catalogItem}}" is not used in any package.json.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isRootWorkspacePackageJson(context.filename)) {
+      return {};
+    }
+    let workspace2;
+    try {
+      workspace2 = getBunWorkspace();
+    } catch {
+      return {};
+    }
+    if (workspace2.hasChanged() || workspace2.hasQueue()) {
+      return {};
+    }
+    workspace2.setContent(context.sourceCode.text);
+    const root = getPackageJsonRootNode(context);
+    if (!root) {
+      return {};
+    }
+    const topCatalog = getProperty2(root, "catalog");
+    const topCatalogs = getProperty2(root, "catalogs");
+    const workspaces = getProperty2(root, "workspaces");
+    const workspacesCatalog = workspaces?.value?.type === "JSONObjectExpression" ? getProperty2(workspaces.value, "catalog") : void 0;
+    const workspacesCatalogs = workspaces?.value?.type === "JSONObjectExpression" ? getProperty2(workspaces.value, "catalogs") : void 0;
+    const catalogNode = topCatalog ?? workspacesCatalog;
+    const catalogsNode = topCatalogs ?? workspacesCatalogs;
+    const entries = /* @__PURE__ */ new Map();
+    if (catalogNode?.value?.type === "JSONObjectExpression") {
+      for (const property of catalogNode.value.properties || []) {
+        entries.set(`${String(property.key.value)}:default`, property);
+      }
+    }
+    if (catalogsNode?.value?.type === "JSONObjectExpression") {
+      for (const named of catalogsNode.value.properties || []) {
+        if (named.value.type !== "JSONObjectExpression") {
+          continue;
+        }
+        const catalogName = String(named.key.value);
+        for (const property of named.value.properties || []) {
+          entries.set(`${String(property.key.value)}:${catalogName}`, property);
+        }
+      }
+    }
+    if (entries.size === 0) {
+      return {};
+    }
+    const packages = collectWorkspacePackageJsonPaths(workspace2);
+    for (const path of packages) {
+      const pkg = JSON.parse(fs.readFileSync(path, "utf8"));
+      for (const field of FIELDS) {
+        const map = getObjectPath(pkg, field.split("."));
+        if (!map) {
+          continue;
+        }
+        for (const [name, value] of Object.entries(map)) {
+          if (typeof value !== "string" || !value.startsWith("catalog:")) {
+            continue;
+          }
+          const catalogName = value.slice(8) || "default";
+          entries.delete(`${name}:${catalogName}`);
+        }
+      }
+    }
+    if (entries.size > 0) {
+      for (const [key, property] of Array.from(entries.entries()).sort(
+        (a, b) => a[0].localeCompare(b[0])
+      )) {
+        context.report({
+          node: property.value,
+          messageId: "unusedCatalogItem",
+          data: { catalogItem: key }
+        });
+      }
+    }
+    return {};
+  }
+});
+
+// ../eslint-plugin-bun/src/rules/json-valid-catalog.ts
+init_esm_shims();
+var RULE_NAME4 = "json-valid-catalog";
+var DEFAULT_FIELDS2 = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies",
+  "resolutions",
+  "overrides"
+];
+var json_valid_catalog_default = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Enforce using valid Bun catalog references in `package.json`"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          autoInsert: {
+            type: "boolean",
+            description: "Whether to auto insert to catalog if missing",
+            default: true
+          },
+          autoInsertDefaultSpecifier: {
+            type: "string",
+            description: "Default specifier to use when auto inserting to catalog",
+            default: "^0.0.0"
+          },
+          autofix: {
+            type: "boolean",
+            description: "Whether to autofix the linting error",
+            default: true
+          },
+          fields: {
+            type: "array",
+            description: "Fields to check for catalog",
+            default: DEFAULT_FIELDS2
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      invalidCatalog: 'Catalog "{{specifier}}" for package "{{packageName}}" is not defined in the workspace root `package.json`.'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const {
+      autoInsert = true,
+      autofix = true,
+      autoInsertDefaultSpecifier = "^0.0.0",
+      fields = DEFAULT_FIELDS2
+    } = options || {};
+    for (const { packageName, specifier, property } of iterateDependencies(
+      context,
+      fields
+    )) {
+      if (!specifier.startsWith("catalog:")) {
+        continue;
+      }
+      let workspace2;
+      try {
+        workspace2 = getBunWorkspace();
+      } catch {
+        return {};
+      }
+      const currentCatalog = specifier.replace(/^catalog:/, "").trim() || "default";
+      const existingCatalogs = workspace2.getPackageCatalogs(packageName);
+      if (!existingCatalogs.includes(currentCatalog)) {
+        context.report({
+          node: property.value,
+          messageId: "invalidCatalog",
+          data: {
+            specifier,
+            packageName
+          },
+          fix: !autofix || !autoInsert && !existingCatalogs.length ? void 0 : (fixer) => {
+            let catalog = existingCatalogs[0];
+            if (!catalog && autoInsert) {
+              catalog = currentCatalog;
+              workspace2.queueChange(() => {
+                workspace2.setPackage(
+                  catalog,
+                  packageName,
+                  autoInsertDefaultSpecifier
+                );
+              }, "pre");
+            }
+            return fixer.replaceText(
+              property.value,
+              catalog === "default" ? JSON.stringify("catalog:") : JSON.stringify(`catalog:${catalog}`)
+            );
+          }
+        });
+      }
+    }
+    return {};
+  }
+});
+
+// ../eslint-plugin-bun/src/plugin.ts
+var plugin = {
+  meta: {
+    name: "bun",
+    version: package_default.version
+  },
+  rules: {
+    "json-enforce-catalog": json_enforce_catalog_default,
+    "json-valid-catalog": json_valid_catalog_default,
+    "json-no-unused-catalog-item": json_no_unused_catalog_item_default,
+    "json-no-duplicate-catalog-item": json_no_duplicate_catalog_item_default
+  }
+};
+
+// ../eslint-plugin-bun/src/configs/recommended.ts
+var config = [
+  {
+    name: "bun/recommended/setup",
+    plugins: {
+      bun: plugin
+    }
+  },
+  {
+    name: "bun/recommended/package-json",
+    ignores: GLOB_EXCLUDE,
+    files: ["package.json", "**/package.json"],
+    languageOptions: {
+      parser: parserJsonc
+    },
+    rules: {
+      "bun/json-enforce-catalog": [
+        "error",
+        {
+          autofix: true,
+          allowedProtocols: ["workspace", "link", "file"],
+          defaultCatalog: "default",
+          reuseExistingCatalog: true,
+          conflicts: "overrides",
+          fields: ["dependencies", "devDependencies"],
+          ignore: ["typescript"]
+        }
+      ],
+      "bun/json-valid-catalog": "error",
+      "bun/json-no-unused-catalog-item": "error",
+      "bun/json-no-duplicate-catalog-item": "error"
+    }
+  }
+];
+var recommended_default = config;
+
+// ../eslint-plugin-bun/src/configs/index.ts
+var configs = {
+  recommended: recommended_default
+};
+
+// ../eslint-plugin-bun/src/index.ts
+var eslintPlugin = {
+  ...plugin,
+  configs
+};
+var src_default = eslintPlugin;
+var rules = plugin.rules;
+
+export { configs, src_default as default, rules };