var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  default: () => src_default,
  rules: () => rules
});
module.exports = __toCommonJS(src_exports);

// src/utils/enforce-node-specifier.ts
var import_node_module = require("module");
function isNodeSpecifier(moduleName) {
  return moduleName.startsWith("node:");
}
function isNativeModule(moduleName) {
  return import_node_module.builtinModules.includes(moduleName);
}
var rule = {
  meta: {
    type: "problem",
    docs: {
      description: "enforce the use of node: specifier for native Node.js modules"
    },
    fixable: "code",
    schema: [],
    // no options
    messages: {
      enforceNodeSpecifier: `Use 'node:{{name}}' instead of '{{name}}'`
    }
  },
  create(context) {
    return {
      ImportDeclaration(node) {
        const moduleName = node.source.value;
        if (typeof moduleName === "string" && isNativeModule(moduleName) && !isNodeSpecifier(moduleName)) {
          context.report({
            node: node.source,
            messageId: "enforceNodeSpecifier",
            data: { name: moduleName },
            fix(fixer) {
              return fixer.replaceText(node.source, `'node:${moduleName}'`);
            }
          });
        }
      },
      CallExpression(node) {
        if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string") {
          const moduleName = node.arguments[0].value;
          if (isNativeModule(moduleName) && !isNodeSpecifier(moduleName)) {
            context.report({
              node: node.arguments[0],
              messageId: "enforceNodeSpecifier",
              data: { name: moduleName },
              fix(fixer) {
                return fixer.replaceText(node.arguments[0], `'node:${moduleName}'`);
              }
            });
          }
        }
      }
    };
  }
};
var enforce_node_specifier_default = rule;

// src/utils/disallow-node-specifier.ts
var import_node_module2 = require("module");
function isNodeSpecifier2(moduleName) {
  return moduleName.startsWith("node:");
}
function isNativeModule2(moduleName) {
  return import_node_module2.builtinModules.includes(moduleName.replace(/^node:/, ""));
}
var rule2 = {
  meta: {
    type: "problem",
    docs: {
      description: "disallow the use of node: specifier for native Node.js modules"
    },
    fixable: "code",
    schema: [],
    // no options
    messages: {
      disallowNodeSpecifier: `Do not use 'node:{{name}}', use '{{name}}' instead`
    }
  },
  create(context) {
    return {
      ImportDeclaration(node) {
        const moduleName = node.source.value;
        if (typeof moduleName === "string" && isNativeModule2(moduleName) && isNodeSpecifier2(moduleName)) {
          const name = moduleName.replace(/^node:/, "");
          context.report({
            node: node.source,
            messageId: "disallowNodeSpecifier",
            data: { name },
            fix(fixer) {
              return fixer.replaceText(node.source, `'${name}'`);
            }
          });
        }
      },
      CallExpression(node) {
        if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string") {
          const moduleName = node.arguments[0].value;
          if (typeof moduleName === "string" && isNativeModule2(moduleName) && isNodeSpecifier2(moduleName)) {
            const name = moduleName.replace(/^node:/, "");
            context.report({
              node: node.arguments[0],
              messageId: "disallowNodeSpecifier",
              data: { name },
              fix(fixer) {
                return fixer.replaceText(node.arguments[0], `'${name}'`);
              }
            });
          }
        }
      }
    };
  }
};
var disallow_node_specifier_default = rule2;

// src/index.ts
var rules = {
  "enforce-node-specifier": enforce_node_specifier_default,
  "disallow-node-specifier": disallow_node_specifier_default
};
var src_default = {
  rules
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  rules
});