bouncevalidator 0.0.1

package/dist/bin/cli.js

@@ -0,0 +1,2229 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/cli.ts
+var import_fs = __toESM(require("fs"));
+var import_readline = __toESM(require("readline"));
+
+// src/utils/normalize.ts
+function normalizeEmail(email, options = {}) {
+  let normalized = email.trim().toLowerCase();
+  const atIndex = normalized.indexOf("@");
+  if (atIndex === -1) {
+    return normalized;
+  }
+  let username = normalized.slice(0, atIndex);
+  const domain = normalized.slice(atIndex + 1);
+  if (options.removePlusAddressing) {
+    const plusIndex = username.indexOf("+");
+    if (plusIndex !== -1) {
+      username = username.slice(0, plusIndex);
+    }
+  }
+  if (options.removeDots) {
+    const gmailDomains = ["gmail.com", "googlemail.com"];
+    if (gmailDomains.includes(domain)) {
+      username = username.replace(/\./g, "");
+    }
+  }
+  return `${username}@${domain}`;
+}
+function extractParts(email) {
+  const atIndex = email.indexOf("@");
+  if (atIndex === -1 || atIndex === 0 || atIndex === email.length - 1) {
+    return null;
+  }
+  if (email.indexOf("@", atIndex + 1) !== -1) {
+    return null;
+  }
+  return {
+    username: email.slice(0, atIndex),
+    domain: email.slice(atIndex + 1)
+  };
+}
+function cleanDomain(domain) {
+  let cleaned = domain.trim().toLowerCase();
+  if (cleaned.endsWith(".")) {
+    cleaned = cleaned.slice(0, -1);
+  }
+  return cleaned;
+}
+
+// src/utils/suggestions.ts
+var domainTypos = {
+  // Gmail typos
+  "gmial.com": "gmail.com",
+  "gmal.com": "gmail.com",
+  "gamil.com": "gmail.com",
+  "gnail.com": "gmail.com",
+  "gmaill.com": "gmail.com",
+  "gmali.com": "gmail.com",
+  "gmai.com": "gmail.com",
+  "gmail.co": "gmail.com",
+  "gmail.om": "gmail.com",
+  "gmail.cm": "gmail.com",
+  "gmail.cim": "gmail.com",
+  "gmail.con": "gmail.com",
+  "gmail.vom": "gmail.com",
+  "gmail.xom": "gmail.com",
+  "gmail.comm": "gmail.com",
+  "gmail.ocm": "gmail.com",
+  "gmaul.com": "gmail.com",
+  "gmeil.com": "gmail.com",
+  "gmsil.com": "gmail.com",
+  "gmqil.com": "gmail.com",
+  "gemail.com": "gmail.com",
+  "g]mail.com": "gmail.com",
+  "fmail.com": "gmail.com",
+  // Yahoo typos
+  "yaho.com": "yahoo.com",
+  "yahooo.com": "yahoo.com",
+  "yhoo.com": "yahoo.com",
+  "yhaoo.com": "yahoo.com",
+  "yaoo.com": "yahoo.com",
+  "yahoo.co": "yahoo.com",
+  "yahoo.om": "yahoo.com",
+  "yahoo.cm": "yahoo.com",
+  "yahoo.con": "yahoo.com",
+  "yahoo.vom": "yahoo.com",
+  "tahoo.com": "yahoo.com",
+  "uahoo.com": "yahoo.com",
+  "yagoo.com": "yahoo.com",
+  // Hotmail typos
+  "hotmial.com": "hotmail.com",
+  "hotmal.com": "hotmail.com",
+  "hotmai.com": "hotmail.com",
+  "homail.com": "hotmail.com",
+  "hotmil.com": "hotmail.com",
+  "hotamail.com": "hotmail.com",
+  "hotmaill.com": "hotmail.com",
+  "hotmail.co": "hotmail.com",
+  "hotmail.om": "hotmail.com",
+  "hotmail.cm": "hotmail.com",
+  "hotmail.con": "hotmail.com",
+  "hitmail.com": "hotmail.com",
+  "hormail.com": "hotmail.com",
+  "hptmail.com": "hotmail.com",
+  "hotmaiil.com": "hotmail.com",
+  // Outlook typos
+  "outlok.com": "outlook.com",
+  "outloo.com": "outlook.com",
+  "outlook.co": "outlook.com",
+  "outlook.om": "outlook.com",
+  "outlook.cm": "outlook.com",
+  "outlook.con": "outlook.com",
+  "outllook.com": "outlook.com",
+  "outlookk.com": "outlook.com",
+  "outloook.com": "outlook.com",
+  "putlook.com": "outlook.com",
+  "oitlook.com": "outlook.com",
+  "outlool.com": "outlook.com",
+  // iCloud typos
+  "iclould.com": "icloud.com",
+  "icloud.co": "icloud.com",
+  "icloud.om": "icloud.com",
+  "icoud.com": "icloud.com",
+  "icloude.com": "icloud.com",
+  "iclud.com": "icloud.com",
+  "iclod.com": "icloud.com",
+  // Protonmail typos
+  "protonmal.com": "protonmail.com",
+  "protonmial.com": "protonmail.com",
+  "protonmai.com": "protonmail.com",
+  "protonmail.co": "protonmail.com",
+  "protonmail.om": "protonmail.com",
+  "protonmail.cm": "protonmail.com",
+  "protnmail.com": "protonmail.com",
+  "protommail.com": "protonmail.com",
+  // AOL typos
+  "aol.co": "aol.com",
+  "aol.om": "aol.com",
+  "aol.cm": "aol.com",
+  "ao.com": "aol.com",
+  "aoll.com": "aol.com",
+  // Live typos
+  "live.co": "live.com",
+  "live.om": "live.com",
+  "live.cm": "live.com",
+  "live.con": "live.com",
+  "livve.com": "live.com",
+  // MSN typos
+  "msn.co": "msn.com",
+  "msn.om": "msn.com",
+  "msn.cm": "msn.com",
+  "mns.com": "msn.com",
+  // Common TLD typos
+  ".con": ".com",
+  ".vom": ".com",
+  ".cpm": ".com",
+  ".ocm": ".com",
+  ".co,": ".com",
+  ".xom": ".com",
+  ".cim": ".com",
+  ".comm": ".com",
+  ".ner": ".net",
+  ".nte": ".net",
+  ".nett": ".net",
+  ".rog": ".org",
+  ".ogr": ".org",
+  ".orgg": ".org"
+};
+var popularDomains = [
+  "gmail.com",
+  "yahoo.com",
+  "hotmail.com",
+  "outlook.com",
+  "icloud.com",
+  "aol.com",
+  "protonmail.com",
+  "live.com",
+  "msn.com",
+  "mail.com",
+  "zoho.com",
+  "yandex.com",
+  "gmx.com",
+  "fastmail.com"
+];
+function levenshteinDistance(str1, str2) {
+  const m = str1.length;
+  const n = str2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      }
+    }
+  }
+  return dp[m][n];
+}
+function getSuggestion(domain) {
+  const lowerDomain = domain.toLowerCase();
+  if (popularDomains.includes(lowerDomain)) {
+    return null;
+  }
+  if (domainTypos[lowerDomain]) {
+    return domainTypos[lowerDomain];
+  }
+  for (const [typo, correction] of Object.entries(domainTypos)) {
+    if (typo.startsWith(".") && lowerDomain.endsWith(typo)) {
+      return lowerDomain.slice(0, -typo.length) + correction;
+    }
+  }
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const popular of popularDomains) {
+    const distance = levenshteinDistance(lowerDomain, popular);
+    if (distance > 0 && distance <= 2 && distance < bestDistance) {
+      bestDistance = distance;
+      bestMatch = popular;
+    }
+  }
+  return bestMatch;
+}
+function getEmailSuggestion(email) {
+  const atIndex = email.indexOf("@");
+  if (atIndex === -1) return null;
+  const username = email.slice(0, atIndex);
+  const domain = email.slice(atIndex + 1);
+  const suggestedDomain = getSuggestion(domain);
+  if (suggestedDomain && suggestedDomain !== domain.toLowerCase()) {
+    return `${username}@${suggestedDomain}`;
+  }
+  return null;
+}
+
+// src/validators/syntax.ts
+var EMAIL_REGEX = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;
+var SIMPLE_EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var MAX_EMAIL_LENGTH = 254;
+var MAX_LOCAL_LENGTH = 64;
+var MAX_DOMAIN_LENGTH = 253;
+function validateSyntax(email) {
+  const trimmedEmail = email.trim();
+  const normalizedEmail = normalizeEmail(trimmedEmail);
+  const invalidResult = {
+    address: trimmedEmail,
+    domain: "",
+    username: "",
+    isValidSyntax: false,
+    normalizedEmail,
+    suggestion: getEmailSuggestion(normalizedEmail)
+  };
+  if (!trimmedEmail) {
+    return invalidResult;
+  }
+  if (trimmedEmail.length > MAX_EMAIL_LENGTH) {
+    return invalidResult;
+  }
+  const parts = extractParts(trimmedEmail);
+  if (!parts) {
+    return invalidResult;
+  }
+  const { username, domain } = parts;
+  if (username.length > MAX_LOCAL_LENGTH) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  if (domain.length > MAX_DOMAIN_LENGTH) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  if (!username || !domain) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  if (!domain.includes(".") && !domain.startsWith("[")) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  const labels = domain.split(".");
+  for (const label of labels) {
+    if (label.length === 0 || label.length > 63) {
+      return {
+        ...invalidResult,
+        domain,
+        username
+      };
+    }
+    if (label.startsWith("-") || label.endsWith("-")) {
+      return {
+        ...invalidResult,
+        domain,
+        username
+      };
+    }
+    if (!/^[a-z0-9-]+$/i.test(label)) {
+      return {
+        ...invalidResult,
+        domain,
+        username
+      };
+    }
+  }
+  const tld = labels[labels.length - 1];
+  if (tld.length < 2 || !/^[a-z]+$/i.test(tld)) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  if (!SIMPLE_EMAIL_REGEX.test(trimmedEmail)) {
+    return {
+      ...invalidResult,
+      domain,
+      username
+    };
+  }
+  const isValid = EMAIL_REGEX.test(trimmedEmail);
+  return {
+    address: trimmedEmail,
+    domain: domain.toLowerCase(),
+    username,
+    isValidSyntax: isValid,
+    normalizedEmail,
+    suggestion: isValid ? getEmailSuggestion(normalizedEmail) : invalidResult.suggestion
+  };
+}
+
+// src/validators/dns.ts
+var import_dns = __toESM(require("dns"));
+var import_util = require("util");
+
+// src/utils/cache.ts
+var DnsCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttl;
+  /**
+   * Create a new DNS cache
+   * @param ttl Time-to-live in milliseconds (default: 5 minutes)
+   */
+  constructor(ttl = 3e5) {
+    this.ttl = ttl;
+  }
+  /**
+   * Get a cached entry for a domain
+   * @param domain The domain to look up
+   * @returns The cached entry or null if not found/expired
+   */
+  get(domain) {
+    const key = domain.toLowerCase();
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry;
+  }
+  /**
+   * Set a cache entry for a domain
+   * @param domain The domain to cache
+   * @param records The MX records
+   * @param acceptsMail Whether the domain accepts mail
+   */
+  set(domain, records, acceptsMail) {
+    const key = domain.toLowerCase();
+    this.cache.set(key, {
+      records,
+      acceptsMail,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Remove expired entries from the cache
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Get the number of cached entries
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Set the TTL for the cache
+   * @param ttl Time-to-live in milliseconds
+   */
+  setTtl(ttl) {
+    this.ttl = ttl;
+  }
+};
+var globalDnsCache = new DnsCache();
+
+// src/validators/dns.ts
+var resolveMx = (0, import_util.promisify)(import_dns.default.resolveMx);
+var resolve4 = (0, import_util.promisify)(import_dns.default.resolve4);
+var resolve6 = (0, import_util.promisify)(import_dns.default.resolve6);
+function sortMxRecords(records) {
+  return records.sort((a, b) => a.priority - b.priority).map((r) => cleanDomain(r.exchange));
+}
+async function verifyMx(domain, options = {}, cache) {
+  const cleanedDomain = cleanDomain(domain);
+  const dnsCache = cache || globalDnsCache;
+  if (options.useDnsCache !== false) {
+    const cached = dnsCache.get(cleanedDomain);
+    if (cached) {
+      return {
+        acceptsMail: cached.acceptsMail,
+        records: cached.records
+      };
+    }
+  }
+  try {
+    const mxRecords = await resolveMx(cleanedDomain);
+    if (!mxRecords || mxRecords.length === 0) {
+      return await fallbackToAddressRecords(cleanedDomain, dnsCache, options);
+    }
+    if (mxRecords.length === 1 && mxRecords[0].priority === 0 && (mxRecords[0].exchange === "" || mxRecords[0].exchange === "." || mxRecords[0].exchange === "0.0.0.0")) {
+      const result2 = {
+        acceptsMail: false,
+        records: []
+      };
+      if (options.useDnsCache !== false) {
+        dnsCache.set(cleanedDomain, [], false);
+      }
+      return result2;
+    }
+    const sortedRecords = sortMxRecords(mxRecords);
+    const validRecords = sortedRecords.filter(
+      (r) => r && r !== "" && r !== "." && r !== "0.0.0.0" && r !== "localhost"
+    );
+    if (validRecords.length === 0) {
+      return await fallbackToAddressRecords(cleanedDomain, dnsCache, options);
+    }
+    const result = {
+      acceptsMail: true,
+      records: validRecords
+    };
+    if (options.useDnsCache !== false) {
+      dnsCache.set(cleanedDomain, validRecords, true);
+    }
+    return result;
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENODATA" || err.code === "ENOTFOUND") {
+      return await fallbackToAddressRecords(cleanedDomain, dnsCache, options);
+    }
+    if (err.code === "ENOTFOUND" || err.code === "SERVFAIL") {
+      const result = {
+        acceptsMail: false,
+        records: []
+      };
+      if (options.useDnsCache !== false) {
+        dnsCache.set(cleanedDomain, [], false);
+      }
+      return result;
+    }
+    return {
+      acceptsMail: false,
+      records: []
+    };
+  }
+}
+async function fallbackToAddressRecords(domain, cache, options) {
+  try {
+    const aRecords = await resolve4(domain);
+    if (aRecords && aRecords.length > 0) {
+      const result2 = {
+        acceptsMail: true,
+        records: [domain]
+        // Use the domain itself as the mail host
+      };
+      if (options.useDnsCache !== false) {
+        cache.set(domain, [domain], true);
+      }
+      return result2;
+    }
+  } catch {
+  }
+  try {
+    const aaaaRecords = await resolve6(domain);
+    if (aaaaRecords && aaaaRecords.length > 0) {
+      const result2 = {
+        acceptsMail: true,
+        records: [domain]
+        // Use the domain itself as the mail host
+      };
+      if (options.useDnsCache !== false) {
+        cache.set(domain, [domain], true);
+      }
+      return result2;
+    }
+  } catch {
+  }
+  const result = {
+    acceptsMail: false,
+    records: []
+  };
+  if (options.useDnsCache !== false) {
+    cache.set(domain, [], false);
+  }
+  return result;
+}
+
+// src/validators/smtp.ts
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var SMTP_PORT = 25;
+var DEFAULT_TIMEOUT = 1e4;
+var SmtpErrorType = {
+  CONNECTION_FAILED: "ConnectionFailed",
+  TIMEOUT: "Timeout",
+  INVALID_RESPONSE: "InvalidResponse",
+  HELO_FAILED: "HeloFailed",
+  MAIL_FROM_FAILED: "MailFromFailed",
+  RCPT_TO_FAILED: "RcptToFailed",
+  MAILBOX_NOT_FOUND: "MailboxNotFound",
+  MAILBOX_DISABLED: "MailboxDisabled",
+  GREYLISTED: "Greylisted",
+  BLOCKED: "Blocked",
+  UNKNOWN: "Unknown"
+};
+function parseResponse(data) {
+  const lines = data.trim().split("\r\n");
+  const lastLine = lines[lines.length - 1];
+  const code = parseInt(lastLine.substring(0, 3), 10);
+  const message = lastLine.substring(4);
+  return { code, message };
+}
+function isSuccessResponse(code) {
+  return code >= 200 && code < 400;
+}
+function sendCommand(socket, command, timeout) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error("Command timeout"));
+    }, timeout);
+    const onData = (data) => {
+      clearTimeout(timeoutId);
+      socket.removeListener("data", onData);
+      socket.removeListener("error", onError);
+      const response = parseResponse(data.toString());
+      resolve(response);
+    };
+    const onError = (err) => {
+      clearTimeout(timeoutId);
+      socket.removeListener("data", onData);
+      reject(err);
+    };
+    socket.once("data", onData);
+    socket.once("error", onError);
+    if (command) {
+      socket.write(command + "\r\n");
+    }
+  });
+}
+function waitForGreeting(socket, timeout) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error("Greeting timeout"));
+    }, timeout);
+    const onData = (data) => {
+      clearTimeout(timeoutId);
+      socket.removeListener("data", onData);
+      socket.removeListener("error", onError);
+      const response = parseResponse(data.toString());
+      resolve(response);
+    };
+    const onError = (err) => {
+      clearTimeout(timeoutId);
+      socket.removeListener("data", onData);
+      reject(err);
+    };
+    socket.once("data", onData);
+    socket.once("error", onError);
+  });
+}
+function generateRandomEmail(domain) {
+  const random = Math.random().toString(36).substring(2, 15);
+  return `${random}@${domain}`;
+}
+async function verifySmtp(email, mxHost, options = {}) {
+  const timeout = options.smtpTimeout || DEFAULT_TIMEOUT;
+  const heloHost = options.heloHost || import_os.default.hostname() || "localhost";
+  const senderAddress = options.senderAddress || "";
+  const detectCatchAll = options.detectCatchAll !== false;
+  const domain = email.split("@")[1];
+  return new Promise((resolve) => {
+    const socket = new import_net.default.Socket();
+    let resolved = false;
+    const cleanup = () => {
+      if (!socket.destroyed) {
+        try {
+          socket.write("QUIT\r\n");
+        } catch {
+        }
+        socket.destroy();
+      }
+    };
+    const finish = (result) => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        resolve(result);
+      }
+    };
+    socket.setTimeout(timeout);
+    socket.on("timeout", () => {
+      finish({
+        canConnectSmtp: false,
+        isDeliverable: false,
+        isCatchAll: false,
+        error: {
+          type: SmtpErrorType.TIMEOUT,
+          message: "Connection timed out"
+        }
+      });
+    });
+    socket.on("error", (err) => {
+      finish({
+        canConnectSmtp: false,
+        isDeliverable: false,
+        isCatchAll: false,
+        error: {
+          type: SmtpErrorType.CONNECTION_FAILED,
+          message: err.message
+        }
+      });
+    });
+    socket.connect(SMTP_PORT, mxHost, async () => {
+      try {
+        const greeting = await waitForGreeting(socket, timeout);
+        if (!isSuccessResponse(greeting.code)) {
+          finish({
+            canConnectSmtp: false,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.BLOCKED,
+              message: `Server rejected connection: ${greeting.message}`
+            }
+          });
+          return;
+        }
+        let heloResponse = await sendCommand(socket, `EHLO ${heloHost}`, timeout);
+        if (!isSuccessResponse(heloResponse.code)) {
+          heloResponse = await sendCommand(socket, `HELO ${heloHost}`, timeout);
+          if (!isSuccessResponse(heloResponse.code)) {
+            finish({
+              canConnectSmtp: true,
+              isDeliverable: false,
+              isCatchAll: false,
+              error: {
+                type: SmtpErrorType.HELO_FAILED,
+                message: `HELO failed: ${heloResponse.message}`
+              }
+            });
+            return;
+          }
+        }
+        const mailFromResponse = await sendCommand(
+          socket,
+          `MAIL FROM:<${senderAddress}>`,
+          timeout
+        );
+        if (!isSuccessResponse(mailFromResponse.code)) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.MAIL_FROM_FAILED,
+              message: `MAIL FROM failed: ${mailFromResponse.message}`
+            }
+          });
+          return;
+        }
+        const rcptResponse = await sendCommand(socket, `RCPT TO:<${email}>`, timeout);
+        let isCatchAll = false;
+        if (detectCatchAll && isSuccessResponse(rcptResponse.code)) {
+          const randomEmail = generateRandomEmail(domain);
+          const catchAllResponse = await sendCommand(
+            socket,
+            `RCPT TO:<${randomEmail}>`,
+            timeout
+          );
+          isCatchAll = isSuccessResponse(catchAllResponse.code);
+        }
+        if (isSuccessResponse(rcptResponse.code)) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: true,
+            isCatchAll,
+            error: null
+          });
+        } else if (rcptResponse.code === 550) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.MAILBOX_NOT_FOUND,
+              message: rcptResponse.message
+            }
+          });
+        } else if (rcptResponse.code === 551 || rcptResponse.code === 553) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.MAILBOX_NOT_FOUND,
+              message: rcptResponse.message
+            }
+          });
+        } else if (rcptResponse.code === 552) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.MAILBOX_DISABLED,
+              message: rcptResponse.message
+            }
+          });
+        } else if (rcptResponse.code === 450 || rcptResponse.code === 451) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.GREYLISTED,
+              message: rcptResponse.message
+            }
+          });
+        } else if (rcptResponse.code >= 500) {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.RCPT_TO_FAILED,
+              message: rcptResponse.message
+            }
+          });
+        } else {
+          finish({
+            canConnectSmtp: true,
+            isDeliverable: false,
+            isCatchAll: false,
+            error: {
+              type: SmtpErrorType.UNKNOWN,
+              message: `Unexpected response code ${rcptResponse.code}: ${rcptResponse.message}`
+            }
+          });
+        }
+      } catch (err) {
+        const error = err;
+        finish({
+          canConnectSmtp: true,
+          isDeliverable: false,
+          isCatchAll: false,
+          error: {
+            type: SmtpErrorType.UNKNOWN,
+            message: error.message
+          }
+        });
+      }
+    });
+  });
+}
+async function verifySmtpWithFallback(email, mxHosts, options = {}) {
+  if (mxHosts.length === 0) {
+    return {
+      canConnectSmtp: false,
+      isDeliverable: false,
+      isCatchAll: false,
+      error: {
+        type: SmtpErrorType.CONNECTION_FAILED,
+        message: "No MX hosts available"
+      }
+    };
+  }
+  let lastResult = null;
+  for (const mxHost of mxHosts) {
+    const result = await verifySmtp(email, mxHost, options);
+    if (result.isDeliverable || result.error?.type === SmtpErrorType.MAILBOX_NOT_FOUND) {
+      return result;
+    }
+    if (result.canConnectSmtp) {
+      lastResult = result;
+    }
+    if (!result.canConnectSmtp) {
+      lastResult = result;
+      continue;
+    }
+  }
+  return lastResult || {
+    canConnectSmtp: false,
+    isDeliverable: false,
+    isCatchAll: false,
+    error: {
+      type: SmtpErrorType.CONNECTION_FAILED,
+      message: "Failed to connect to any MX host"
+    }
+  };
+}
+
+// src/validators/misc.ts
+var import_crypto = __toESM(require("crypto"));
+var import_https = __toESM(require("https"));
+
+// src/data/disposable.ts
+var disposableDomains = /* @__PURE__ */ new Set([
+  // Popular disposable email services
+  "10minutemail.com",
+  "10minutemail.net",
+  "20minutemail.com",
+  "33mail.com",
+  "guerrillamail.com",
+  "guerrillamail.org",
+  "guerrillamail.net",
+  "guerrillamail.biz",
+  "guerrillamail.de",
+  "guerrillamailblock.com",
+  "sharklasers.com",
+  "grr.la",
+  "pokemail.net",
+  "spam4.me",
+  "mailinator.com",
+  "mailinator.net",
+  "mailinator.org",
+  "mailinator2.com",
+  "mailinater.com",
+  "tempmail.com",
+  "tempmail.net",
+  "temp-mail.org",
+  "temp-mail.io",
+  "tempail.com",
+  "tempmailaddress.com",
+  "throwaway.email",
+  "throwawaymail.com",
+  "trashmail.com",
+  "trashmail.net",
+  "trashmail.org",
+  "trashmail.me",
+  "trashemail.de",
+  "fakeinbox.com",
+  "fakemailgenerator.com",
+  "getnada.com",
+  "nada.email",
+  "getairmail.com",
+  "airmail.cc",
+  "dispostable.com",
+  "disposableemailaddresses.com",
+  "emailondeck.com",
+  "yopmail.com",
+  "yopmail.fr",
+  "yopmail.net",
+  "cool.fr.nf",
+  "jetable.fr.nf",
+  "nospam.ze.tc",
+  "nomail.xl.cx",
+  "mega.zik.dj",
+  "speed.1s.fr",
+  "courriel.fr.nf",
+  "moncourrier.fr.nf",
+  "monemail.fr.nf",
+  "monmail.fr.nf",
+  "mohmal.com",
+  "mailnesia.com",
+  "maildrop.cc",
+  "mailsac.com",
+  "mintemail.com",
+  "mytemp.email",
+  "mytrashmail.com",
+  "nowmymail.com",
+  "spambox.us",
+  "spamfree24.org",
+  "spamgourmet.com",
+  "spamspot.com",
+  "tempinbox.com",
+  "tempomail.fr",
+  "temporaryemail.net",
+  "temporaryforwarding.com",
+  "temporaryinbox.com",
+  "thankyou2010.com",
+  "thisisnotmyrealemail.com",
+  "throam.com",
+  "tmail.ws",
+  "tmpmail.net",
+  "tmpmail.org",
+  "wegwerfmail.de",
+  "wegwerfmail.net",
+  "wegwerfmail.org",
+  "wh4f.org",
+  "willhackforfood.biz",
+  "willselfdestruct.com",
+  "emailfake.com",
+  "emkei.cz",
+  "anonymbox.com",
+  "discard.email",
+  "discardmail.com",
+  "discardmail.de",
+  "spambog.com",
+  "spambog.de",
+  "spambog.ru",
+  "mailcatch.com",
+  "mail-temp.com",
+  "mailtemp.info",
+  "mailzilla.com",
+  "mailzilla.org",
+  "binkmail.com",
+  "bobmail.info",
+  "burnthespam.info",
+  "buyusedlibrarybooks.org",
+  "byom.de",
+  "deadaddress.com",
+  "despam.it",
+  "devnullmail.com",
+  "dfgh.net",
+  "e4ward.com",
+  "emailias.com",
+  "emailigo.de",
+  "emailsensei.com",
+  "emailtemporario.com.br",
+  "emailwarden.com",
+  "explodemail.com",
+  "fastacura.com",
+  "filzmail.com",
+  "fizmail.com",
+  "frapmail.com",
+  "gishpuppy.com",
+  "great-host.in",
+  "greensloth.com",
+  "haltospam.com",
+  "hidzz.com",
+  "hmamail.com",
+  "imails.info",
+  "incognitomail.com",
+  "incognitomail.net",
+  "incognitomail.org",
+  "infocom.zp.ua",
+  "instantemailaddress.com",
+  "ipoo.org",
+  "irish2me.com",
+  "jetable.com",
+  "kasmail.com",
+  "klassmaster.com",
+  "klzlv.com",
+  "koszmail.pl",
+  "kulturbetrieb.info",
+  "kurzepost.de",
+  "lawlita.com",
+  "letthemeatspam.com",
+  "lhsdv.com",
+  "lifebyfood.com",
+  "link2mail.net",
+  "litedrop.com",
+  "lol.ovpn.to",
+  "lookugly.com",
+  "lortemail.dk",
+  "lovemeleaveme.com",
+  "lr78.com",
+  "maboard.com",
+  "mail2rss.org",
+  "mail333.com",
+  "mailbidon.com",
+  "mailblocks.com",
+  "maildu.de",
+  "maileater.com",
+  "mailexpire.com",
+  "mailfa.tk",
+  "mailfork.com",
+  "mailfreeonline.com",
+  "mailguard.me",
+  "mailimate.com",
+  "mailin8r.com",
+  "mailinblack.com",
+  "mailincubator.com",
+  "mailme.ir",
+  "mailme.lv",
+  "mailmetrash.com",
+  "mailmoat.com",
+  "mailnull.com",
+  "mailorg.org",
+  "mailscrap.com",
+  "mailshell.com",
+  "mailsiphon.com",
+  "mailslite.com",
+  "mailtemp.net",
+  "mailtothis.com",
+  "mailzi.ru",
+  "makemetheking.com",
+  "mbx.cc",
+  "mega.zik.dj",
+  "meltmail.com",
+  "messagebeamer.de",
+  "mezimages.net",
+  "mierdamail.com",
+  "migmail.pl",
+  "migumail.com",
+  "mintemail.com",
+  "moburl.com",
+  "moncourrier.fr.nf",
+  "monemail.fr.nf",
+  "monmail.fr.nf",
+  "monumentmail.com",
+  "ms51.hinet.net",
+  "msb.minsmail.com",
+  "mt2009.com",
+  "mx0.wwwnew.eu",
+  "mycleaninbox.net",
+  "mypartyclip.de",
+  "myphantomemail.com",
+  "mysamp.de",
+  "myspaceinc.com",
+  "myspaceinc.net",
+  "myspacepimpedup.com",
+  "mytempemail.com",
+  "neomailbox.com",
+  "nepwk.com",
+  "nervmich.net",
+  "nervtmansen.de",
+  "netmails.com",
+  "netmails.net",
+  "netzidiot.de",
+  "neverbox.com",
+  "no-spam.ws",
+  "nobulk.com",
+  "noclickemail.com",
+  "nogmailspam.info",
+  "nomail.xl.cx",
+  "nomail2me.com",
+  "nomorespamemails.com",
+  "nospam.ze.tc",
+  "nospam4.us",
+  "nospamfor.us",
+  "nospammail.net",
+  "notmailinator.com",
+  "nowhere.org",
+  "nowmymail.com",
+  "nurfuerspam.de",
+  "nus.edu.sg",
+  "objectmail.com",
+  "obobbo.com",
+  "oneoffemail.com",
+  "onewaymail.com",
+  "onlatedotcom.info",
+  "online.ms",
+  "oopi.org",
+  "opayq.com",
+  "ordinaryamerican.net",
+  "otherinbox.com",
+  "ourklips.com",
+  "outlawspam.com",
+  "ovpn.to",
+  "owlpic.com",
+  "pancakemail.com",
+  "pjjkp.com",
+  "plexolan.de",
+  "poczta.onet.pl",
+  "politikerclub.de",
+  "poofy.org",
+  "pookmail.com",
+  "privacy.net",
+  "privy-mail.com",
+  "privymail.de",
+  "proxymail.eu",
+  "prtnx.com",
+  "punkass.com",
+  "putthisinyourspamdatabase.com",
+  "qq.com",
+  "quickinbox.com",
+  "quickmail.nl",
+  "rcpt.at",
+  "reallymymail.com",
+  "realtyalerts.ca",
+  "recode.me",
+  "recursor.net",
+  "recyclemail.dk",
+  "regbypass.com",
+  "regbypass.comsafe-mail.net",
+  "rejectmail.com",
+  "remail.cf",
+  "rhyta.com",
+  "rklips.com",
+  "rmqkr.net",
+  "rppkn.com",
+  "rtrtr.com",
+  "s0ny.net",
+  "safe-mail.net",
+  "safersignup.de",
+  "safetymail.info",
+  "safetypost.de",
+  "sandelf.de",
+  "saynotospams.com",
+  "schafmail.de",
+  "selfdestructingmail.com",
+  "sendspamhere.com",
+  "shieldemail.com",
+  "shiftmail.com",
+  "shitmail.me",
+  "shortmail.net",
+  "shut.name",
+  "shut.ws",
+  "sibmail.com",
+  "sinnlos-mail.de",
+  "siteposter.net",
+  "skeefmail.com",
+  "slaskpost.se",
+  "slopsbox.com",
+  "slowfoodfoothills.xyz",
+  "smashmail.de",
+  "smellfear.com",
+  "snakemail.com",
+  "sneakemail.com",
+  "sneakmail.de",
+  "snkmail.com",
+  "sofimail.com",
+  "sofort-mail.de",
+  "softpls.asia",
+  "sogetthis.com",
+  "sohu.com",
+  "soisz.com",
+  "solvemail.info",
+  "soodonims.com",
+  "spam.la",
+  "spam.su",
+  "spamavert.com",
+  "spambob.com",
+  "spambob.net",
+  "spambob.org",
+  "spambog.com",
+  "spambog.de",
+  "spambog.ru",
+  "spambox.info",
+  "spambox.irishspringrealty.com",
+  "spambox.us",
+  "spamcannon.com",
+  "spamcannon.net",
+  "spamcero.com",
+  "spamcon.org",
+  "spamcorptastic.com",
+  "spamcowboy.com",
+  "spamcowboy.net",
+  "spamcowboy.org",
+  "spamday.com",
+  "spamex.com",
+  "spamfree.eu",
+  "spamfree24.com",
+  "spamfree24.de",
+  "spamfree24.eu",
+  "spamfree24.info",
+  "spamfree24.net",
+  "spamfree24.org",
+  "spamgoes.in",
+  "spamherelots.com",
+  "spamhereplease.com",
+  "spamhole.com",
+  "spamify.com",
+  "spaminator.de",
+  "spamkill.info",
+  "spaml.com",
+  "spaml.de",
+  "spammotel.com",
+  "spamobox.com",
+  "spamoff.de",
+  "spamsalad.in",
+  "spamslicer.com",
+  "spamspot.com",
+  "spamstack.net",
+  "spamthis.co.uk",
+  "spamtroll.net",
+  "speed.1s.fr",
+  "spoofmail.de",
+  "squizzy.de",
+  "ssoia.com",
+  "startkeys.com",
+  "stinkefinger.net",
+  "stop-my-spam.cf",
+  "stop-my-spam.com",
+  "stop-my-spam.ga",
+  "stop-my-spam.ml",
+  "stop-my-spam.tk",
+  "streetwisemail.com",
+  "stuffmail.de",
+  "supergreatmail.com",
+  "supermailer.jp",
+  "superrito.com",
+  "superstachel.de",
+  "suremail.info",
+  "svk.jp",
+  "sweetxxx.de",
+  "tagyourself.com",
+  "talkinator.com",
+  "tapchicuoihoi.com",
+  "techemail.com",
+  "techgroup.me",
+  "teewars.org",
+  "teleosaurs.xyz",
+  "teleworm.com",
+  "teleworm.us",
+  "temp.emeraldwebmail.com",
+  "tempail.com",
+  "tempalias.com",
+  "tempe-mail.com",
+  "tempemail.biz",
+  "tempemail.co.za",
+  "tempemail.com",
+  "tempemail.net",
+  "tempinbox.co.uk",
+  "tempinbox.com",
+  "tempmail.co",
+  "tempmail.de",
+  "tempmail.eu",
+  "tempmail.it",
+  "tempmail.net",
+  "tempmail.us",
+  "tempmail2.com",
+  "tempmaildemo.com",
+  "tempmailer.com",
+  "tempmailer.de",
+  "tempomail.fr",
+  "temporarioemail.com.br",
+  "temporaryemail.net",
+  "temporaryemail.us",
+  "temporaryforwarding.com",
+  "temporaryinbox.com",
+  "temporarymailaddress.com",
+  "tempthe.net",
+  "thankspam.info",
+  "thankyou2010.com",
+  "thecloudindex.com",
+  "thelimestones.com",
+  "thisisnotmyrealemail.com",
+  "throam.com",
+  "throwam.com",
+  "throwawayemailaddress.com",
+  "throwawaymail.com",
+  "tilien.com",
+  "tittbit.in",
+  "tmailinator.com",
+  "tmail.ws",
+  "toiea.com",
+  "tokenmail.de",
+  "toomail.biz",
+  "topranklist.de",
+  "tradermail.info",
+  "trash-amil.com",
+  "trash-mail.at",
+  "trash-mail.com",
+  "trash-mail.de",
+  "trash2009.com",
+  "trash2010.com",
+  "trash2011.com",
+  "trashcanmail.com",
+  "trashdevil.com",
+  "trashdevil.de",
+  "trashemail.de",
+  "trashmail.at",
+  "trashmail.com",
+  "trashmail.de",
+  "trashmail.me",
+  "trashmail.net",
+  "trashmail.org",
+  "trashmail.ws",
+  "trashmailer.com",
+  "trashymail.com",
+  "trashymail.net",
+  "trbvm.com",
+  "trickmail.net",
+  "trillianpro.com",
+  "tryalert.com",
+  "turual.com",
+  "twinmail.de",
+  "tyldd.com",
+  "uggsrock.com",
+  "umail.net",
+  "upliftnow.com",
+  "uplipht.com",
+  "uroid.com",
+  "us.af",
+  "valemail.net",
+  "venompen.com",
+  "veryrealemail.com",
+  "viditag.com",
+  "viralplays.com",
+  "vpn.st",
+  "vsimcard.com",
+  "vubby.com",
+  "wasteland.rfc822.org",
+  "webemail.me",
+  "webm4il.info",
+  "webuser.in",
+  "wee.my",
+  "weg-werf-email.de",
+  "wegwerf-emails.de",
+  "wegwerfadresse.de",
+  "wegwerfemail.com",
+  "wegwerfemail.de",
+  "wegwerfmail.de",
+  "wegwerfmail.info",
+  "wegwerfmail.net",
+  "wegwerfmail.org",
+  "wetrainbayarea.com",
+  "wetrainbayarea.org",
+  "wh4f.org",
+  "whatiaas.com",
+  "whatpaas.com",
+  "whopy.com",
+  "whtjddn.33mail.com",
+  "whyspam.me",
+  "willhackforfood.biz",
+  "willselfdestruct.com",
+  "winemaven.info",
+  "wolfsmail.tk",
+  "wollan.info",
+  "worldspace.link",
+  "wpdork.com",
+  "wronghead.com",
+  "wuzup.net",
+  "wuzupmail.net",
+  "wwwnew.eu",
+  "xagloo.co",
+  "xagloo.com",
+  "xemaps.com",
+  "xents.com",
+  "xmaily.com",
+  "xoxy.net",
+  "yapped.net",
+  "yep.it",
+  "yogamaven.com",
+  "yomail.info",
+  "yopmail.com",
+  "yopmail.fr",
+  "yopmail.gq",
+  "yopmail.net",
+  "you-spam.com",
+  "yourdomain.com",
+  "ypmail.webarnak.fr.eu.org",
+  "yuurok.com",
+  "za.com",
+  "zehnminuten.de",
+  "zehnminutenmail.de",
+  "zippymail.info",
+  "zoaxe.com",
+  "zoemail.com",
+  "zoemail.net",
+  "zoemail.org",
+  "zomg.info",
+  "zxcv.com",
+  "zxcvbnm.com",
+  "zzz.com"
+]);
+function isDisposableDomain(domain) {
+  return disposableDomains.has(domain.toLowerCase());
+}
+
+// src/data/roles.ts
+var rolePrefixes = /* @__PURE__ */ new Set([
+  // Administrative
+  "admin",
+  "administrator",
+  "postmaster",
+  "hostmaster",
+  "webmaster",
+  "root",
+  "sysadmin",
+  "it",
+  "tech",
+  "technical",
+  // Support
+  "support",
+  "help",
+  "helpdesk",
+  "customerservice",
+  "customer-service",
+  "customercare",
+  "customer-care",
+  "service",
+  "assist",
+  "assistance",
+  // Sales and Marketing
+  "sales",
+  "marketing",
+  "advertising",
+  "ads",
+  "promo",
+  "promotions",
+  "partners",
+  "partnership",
+  "partnerships",
+  "affiliate",
+  "affiliates",
+  "leads",
+  "enquiry",
+  "enquiries",
+  "inquiry",
+  "inquiries",
+  // General Contact
+  "info",
+  "information",
+  "contact",
+  "contactus",
+  "contact-us",
+  "hello",
+  "hi",
+  "hey",
+  "mail",
+  "email",
+  "office",
+  "general",
+  "reception",
+  // Human Resources
+  "hr",
+  "humanresources",
+  "human-resources",
+  "jobs",
+  "careers",
+  "career",
+  "recruitment",
+  "recruiting",
+  "talent",
+  "hiring",
+  "resume",
+  "resumes",
+  "cv",
+  "employment",
+  // Finance and Legal
+  "billing",
+  "finance",
+  "accounting",
+  "accounts",
+  "payroll",
+  "invoices",
+  "invoice",
+  "payments",
+  "payment",
+  "legal",
+  "compliance",
+  "privacy",
+  "gdpr",
+  // Media and PR
+  "press",
+  "media",
+  "pr",
+  "publicrelations",
+  "public-relations",
+  "news",
+  "newsroom",
+  "communications",
+  "comms",
+  // Security
+  "security",
+  "abuse",
+  "spam",
+  "phishing",
+  "fraud",
+  "noc",
+  "cert",
+  // Operations
+  "operations",
+  "ops",
+  "devops",
+  "engineering",
+  "dev",
+  "development",
+  "product",
+  "feedback",
+  // Team/Group addresses
+  "team",
+  "staff",
+  "all",
+  "everyone",
+  "group",
+  "department",
+  "board",
+  "management",
+  "exec",
+  "executive",
+  "executives",
+  // E-commerce
+  "orders",
+  "order",
+  "shipping",
+  "returns",
+  "refunds",
+  "shop",
+  "store",
+  "buy",
+  "purchase",
+  "checkout",
+  // Automated/System
+  "noreply",
+  "no-reply",
+  "donotreply",
+  "do-not-reply",
+  "mailer-daemon",
+  "mailerdaemon",
+  "bounce",
+  "bounces",
+  "auto",
+  "autoresponder",
+  "notifications",
+  "notification",
+  "alerts",
+  "alert",
+  "updates",
+  "newsletter",
+  "newsletters",
+  "subscribe",
+  "unsubscribe",
+  // Miscellaneous
+  "ftp",
+  "www",
+  "web",
+  "api",
+  "test",
+  "testing",
+  "demo",
+  "sample",
+  "example"
+]);
+function isRolePrefix(prefix) {
+  return rolePrefixes.has(prefix.toLowerCase());
+}
+
+// src/data/free-providers.ts
+var freeProviders = /* @__PURE__ */ new Set([
+  // Google
+  "gmail.com",
+  "googlemail.com",
+  // Microsoft
+  "outlook.com",
+  "outlook.co.uk",
+  "outlook.com.br",
+  "outlook.com.au",
+  "outlook.de",
+  "outlook.fr",
+  "outlook.it",
+  "outlook.es",
+  "outlook.jp",
+  "hotmail.com",
+  "hotmail.co.uk",
+  "hotmail.com.br",
+  "hotmail.com.au",
+  "hotmail.de",
+  "hotmail.fr",
+  "hotmail.it",
+  "hotmail.es",
+  "hotmail.co.jp",
+  "live.com",
+  "live.co.uk",
+  "live.com.au",
+  "live.de",
+  "live.fr",
+  "live.it",
+  "live.nl",
+  "live.se",
+  "msn.com",
+  // Yahoo
+  "yahoo.com",
+  "yahoo.co.uk",
+  "yahoo.com.br",
+  "yahoo.com.au",
+  "yahoo.de",
+  "yahoo.fr",
+  "yahoo.it",
+  "yahoo.es",
+  "yahoo.co.jp",
+  "yahoo.co.in",
+  "yahoo.ca",
+  "yahoo.com.mx",
+  "yahoo.com.ar",
+  "yahoo.com.sg",
+  "yahoo.co.id",
+  "yahoo.com.ph",
+  "yahoo.com.tw",
+  "yahoo.com.hk",
+  "yahoo.ie",
+  "yahoo.co.nz",
+  "yahoo.com.vn",
+  "ymail.com",
+  "rocketmail.com",
+  // Apple
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  // AOL
+  "aol.com",
+  "aol.co.uk",
+  "aol.de",
+  "aol.fr",
+  "aim.com",
+  // Proton
+  "protonmail.com",
+  "protonmail.ch",
+  "proton.me",
+  "pm.me",
+  // Zoho
+  "zoho.com",
+  "zohomail.com",
+  "zohomail.in",
+  "zohomail.eu",
+  // Mail.com
+  "mail.com",
+  "email.com",
+  "usa.com",
+  "myself.com",
+  "consultant.com",
+  "post.com",
+  "europe.com",
+  "asia.com",
+  "iname.com",
+  "writeme.com",
+  "dr.com",
+  "cheerful.com",
+  "accountant.com",
+  "techie.com",
+  "engineer.com",
+  "activist.com",
+  "contractor.com",
+  "artlover.com",
+  // GMX
+  "gmx.com",
+  "gmx.net",
+  "gmx.de",
+  "gmx.at",
+  "gmx.ch",
+  "gmx.fr",
+  "gmx.co.uk",
+  "gmx.us",
+  // Tutanota/Tuta
+  "tutanota.com",
+  "tutanota.de",
+  "tutamail.com",
+  "tuta.io",
+  "keemail.me",
+  // Fastmail
+  "fastmail.com",
+  "fastmail.fm",
+  // Mailfence
+  "mailfence.com",
+  // Hushmail
+  "hushmail.com",
+  "hush.com",
+  "hush.ai",
+  "mac.hush.com",
+  // Runbox
+  "runbox.com",
+  // Posteo
+  "posteo.de",
+  "posteo.net",
+  // Yandex
+  "yandex.com",
+  "yandex.ru",
+  "yandex.ua",
+  "yandex.by",
+  "yandex.kz",
+  "ya.ru",
+  // Mail.ru
+  "mail.ru",
+  "inbox.ru",
+  "list.ru",
+  "bk.ru",
+  // Chinese providers
+  "qq.com",
+  "163.com",
+  "126.com",
+  "sina.com",
+  "sina.cn",
+  "sohu.com",
+  "aliyun.com",
+  "foxmail.com",
+  // Indian providers
+  "rediffmail.com",
+  "rediff.com",
+  // European providers
+  "web.de",
+  "t-online.de",
+  "freenet.de",
+  "arcor.de",
+  "orange.fr",
+  "laposte.net",
+  "free.fr",
+  "sfr.fr",
+  "wanadoo.fr",
+  "libero.it",
+  "virgilio.it",
+  "tin.it",
+  "alice.it",
+  "tiscali.it",
+  "tiscali.co.uk",
+  "terra.com.br",
+  "uol.com.br",
+  "bol.com.br",
+  "ig.com.br",
+  "wp.pl",
+  "onet.pl",
+  "interia.pl",
+  "o2.pl",
+  "seznam.cz",
+  "centrum.cz",
+  "azet.sk",
+  // Misc
+  "inbox.com",
+  "lycos.com",
+  "naver.com",
+  "daum.net",
+  "hanmail.net",
+  "comcast.net",
+  "verizon.net",
+  "att.net",
+  "sbcglobal.net",
+  "bellsouth.net",
+  "charter.net",
+  "cox.net",
+  "earthlink.net",
+  "juno.com",
+  "netzero.net",
+  "optonline.net",
+  "btinternet.com",
+  "talktalk.net",
+  "virginmedia.com",
+  "sky.com",
+  "ntlworld.com",
+  "shaw.ca",
+  "rogers.com",
+  "sympatico.ca",
+  "telus.net",
+  "bigpond.com",
+  "bigpond.net.au",
+  "optusnet.com.au",
+  "ozemail.com.au"
+]);
+function isFreeProvider(domain) {
+  return freeProviders.has(domain.toLowerCase());
+}
+
+// src/validators/misc.ts
+function checkDisposable(domain) {
+  return isDisposableDomain(domain.toLowerCase());
+}
+function checkRoleAccount(username) {
+  const cleanUsername = username.split("+")[0];
+  return isRolePrefix(cleanUsername.toLowerCase());
+}
+function checkFreeProvider(domain) {
+  return isFreeProvider(domain.toLowerCase());
+}
+function md5(str) {
+  return import_crypto.default.createHash("md5").update(str.trim().toLowerCase()).digest("hex");
+}
+function checkGravatar(email) {
+  return new Promise((resolve) => {
+    const hash = md5(email);
+    const url = `https://www.gravatar.com/avatar/${hash}?d=404`;
+    const req = import_https.default.get(url, { timeout: 5e3 }, (res) => {
+      if (res.statusCode === 200) {
+        resolve(`https://www.gravatar.com/avatar/${hash}`);
+      } else {
+        resolve(null);
+      }
+      res.resume();
+    });
+    req.on("error", () => {
+      resolve(null);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+async function checkMisc(email, options = {}) {
+  const atIndex = email.indexOf("@");
+  if (atIndex === -1) {
+    return {
+      isDisposable: false,
+      isRoleAccount: false,
+      isFreeProvider: false,
+      gravatarUrl: null
+    };
+  }
+  const username = email.slice(0, atIndex);
+  const domain = email.slice(atIndex + 1);
+  const isDisposable = options.checkDisposable !== false ? checkDisposable(domain) : false;
+  const isRoleAccount = options.checkRoleAccount !== false ? checkRoleAccount(username) : false;
+  const isFree = options.checkFreeProvider !== false ? checkFreeProvider(domain) : false;
+  let gravatarUrl = null;
+  if (options.checkGravatar === true) {
+    gravatarUrl = await checkGravatar(email);
+  }
+  return {
+    isDisposable,
+    isRoleAccount,
+    isFreeProvider: isFree,
+    gravatarUrl
+  };
+}
+
+// src/index.ts
+var defaultOptions = {
+  smtpTimeout: 1e4,
+  verifySmtp: true,
+  checkDisposable: true,
+  checkRoleAccount: true,
+  checkFreeProvider: true,
+  checkGravatar: false,
+  heloHost: "",
+  senderAddress: "",
+  dnsCacheTtl: 3e5,
+  useDnsCache: true,
+  detectCatchAll: true,
+  proxy: void 0
+};
+function determineReachability(syntaxValid, mxValid, smtpResult, options) {
+  if (!syntaxValid) {
+    return "invalid";
+  }
+  if (!mxValid) {
+    return "invalid";
+  }
+  if (options.verifySmtp === false) {
+    return "risky";
+  }
+  if (!smtpResult) {
+    return "unknown";
+  }
+  if (smtpResult.isCatchAll) {
+    return "risky";
+  }
+  if (smtpResult.isDeliverable) {
+    return "safe";
+  }
+  if (!smtpResult.canConnectSmtp) {
+    return "unknown";
+  }
+  if (smtpResult.error?.type === SmtpErrorType.MAILBOX_NOT_FOUND) {
+    return "invalid";
+  }
+  if (smtpResult.error?.type === SmtpErrorType.GREYLISTED) {
+    return "risky";
+  }
+  return "risky";
+}
+async function validate(email, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  if (opts.useDnsCache && opts.dnsCacheTtl) {
+    globalDnsCache.setTtl(opts.dnsCacheTtl);
+  }
+  const syntaxResult = validateSyntax(email);
+  if (!syntaxResult.isValidSyntax) {
+    return {
+      input: email,
+      isReachable: "invalid",
+      syntax: syntaxResult,
+      mx: {
+        acceptsMail: false,
+        records: []
+      },
+      smtp: {
+        canConnectSmtp: false,
+        isDeliverable: false,
+        isCatchAll: false,
+        error: null
+      },
+      misc: {
+        isDisposable: false,
+        isRoleAccount: false,
+        isFreeProvider: false,
+        gravatarUrl: null
+      }
+    };
+  }
+  const mxResult = await verifyMx(syntaxResult.domain, opts);
+  if (!mxResult.acceptsMail) {
+    const miscResult2 = await checkMisc(email, opts);
+    return {
+      input: email,
+      isReachable: "invalid",
+      syntax: syntaxResult,
+      mx: mxResult,
+      smtp: {
+        canConnectSmtp: false,
+        isDeliverable: false,
+        isCatchAll: false,
+        error: {
+          type: "NoMxRecords",
+          message: "Domain does not accept mail"
+        }
+      },
+      misc: miscResult2
+    };
+  }
+  let smtpResult = {
+    canConnectSmtp: false,
+    isDeliverable: false,
+    isCatchAll: false,
+    error: null
+  };
+  if (opts.verifySmtp) {
+    smtpResult = await verifySmtpWithFallback(email, mxResult.records, opts);
+  }
+  const miscResult = await checkMisc(email, opts);
+  const isReachable = determineReachability(
+    syntaxResult.isValidSyntax,
+    mxResult.acceptsMail,
+    smtpResult,
+    opts
+  );
+  return {
+    input: email,
+    isReachable,
+    syntax: syntaxResult,
+    mx: mxResult,
+    smtp: smtpResult,
+    misc: miscResult
+  };
+}
+async function validateBulk(emails, options = {}) {
+  const { concurrency = 5, delayBetween = 0, onProgress, ...validateOptions } = options;
+  const results = [];
+  let completed = 0;
+  for (let i = 0; i < emails.length; i += concurrency) {
+    const batch = emails.slice(i, i + concurrency);
+    const batchPromises = batch.map(async (email) => {
+      const result = await validate(email, validateOptions);
+      completed++;
+      if (onProgress) {
+        onProgress(completed, emails.length, result);
+      }
+      return result;
+    });
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+    if (delayBetween > 0 && i + concurrency < emails.length) {
+      await new Promise((resolve) => setTimeout(resolve, delayBetween));
+    }
+  }
+  return results;
+}
+async function validateQuick(email) {
+  return validate(email, { verifySmtp: false });
+}
+
+// bin/cli.ts
+function parseArgs(args) {
+  const result = {
+    emails: [],
+    quick: false,
+    pretty: false,
+    verbose: false,
+    timeout: 1e4,
+    concurrency: 5,
+    noSmtp: false,
+    noDisposable: false,
+    noRole: false,
+    noFreeProvider: false,
+    gravatar: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        result.help = true;
+        break;
+      case "-v":
+      case "--version":
+        result.version = true;
+        break;
+      case "-q":
+      case "--quick":
+        result.quick = true;
+        break;
+      case "-p":
+      case "--pretty":
+        result.pretty = true;
+        break;
+      case "--verbose":
+        result.verbose = true;
+        break;
+      case "-f":
+      case "--file":
+        result.file = args[++i];
+        break;
+      case "-o":
+      case "--output":
+        result.output = args[++i];
+        break;
+      case "-t":
+      case "--timeout":
+        result.timeout = parseInt(args[++i], 10);
+        break;
+      case "-c":
+      case "--concurrency":
+        result.concurrency = parseInt(args[++i], 10);
+        break;
+      case "--no-smtp":
+        result.noSmtp = true;
+        break;
+      case "--no-disposable":
+        result.noDisposable = true;
+        break;
+      case "--no-role":
+        result.noRole = true;
+        break;
+      case "--no-free-provider":
+        result.noFreeProvider = true;
+        break;
+      case "--gravatar":
+        result.gravatar = true;
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          result.emails.push(arg);
+        }
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`
+bouncevalidator - Local email validation service
+
+USAGE:
+  bouncevalidator [OPTIONS] <email>...
+  bouncevalidator -f <file> [OPTIONS]
+
+ARGUMENTS:
+  <email>...              Email addresses to validate
+
+OPTIONS:
+  -h, --help              Show this help message
+  -v, --version           Show version number
+  -f, --file <path>       Read emails from file (one per line)
+  -o, --output <path>     Write results to file
+  -q, --quick             Quick mode (skip SMTP verification)
+  -p, --pretty            Pretty print JSON output
+  --verbose               Show detailed progress
+
+VALIDATION OPTIONS:
+  -t, --timeout <ms>      SMTP timeout in milliseconds (default: 10000)
+  -c, --concurrency <n>   Max concurrent validations (default: 5)
+  --no-smtp               Skip SMTP verification
+  --no-disposable         Skip disposable email check
+  --no-role               Skip role account check
+  --no-free-provider      Skip free provider check
+  --gravatar              Check for Gravatar
+
+EXAMPLES:
+  bouncevalidator user@example.com
+  bouncevalidator -p user@example.com user2@example.com
+  bouncevalidator -f emails.txt -o results.json
+  bouncevalidator --quick user@example.com
+
+EXIT CODES:
+  0  All emails are valid (safe)
+  1  One or more emails are invalid
+  2  One or more emails are risky or unknown
+  3  Error occurred during validation
+`);
+}
+function printVersion() {
+  console.log("bouncevalidator v1.0.0");
+}
+async function readEmailsFromFile(filePath) {
+  const emails = [];
+  const fileStream = import_fs.default.createReadStream(filePath);
+  const rl = import_readline.default.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      emails.push(trimmed);
+    }
+  }
+  return emails;
+}
+function formatResult(result, pretty) {
+  return JSON.stringify(result, null, pretty ? 2 : 0);
+}
+function getExitCode(results) {
+  let hasInvalid = false;
+  let hasRisky = false;
+  for (const result of results) {
+    if (result.isReachable === "invalid") {
+      hasInvalid = true;
+    } else if (result.isReachable === "risky" || result.isReachable === "unknown") {
+      hasRisky = true;
+    }
+  }
+  if (hasInvalid) return 1;
+  if (hasRisky) return 2;
+  return 0;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.version) {
+    printVersion();
+    process.exit(0);
+  }
+  let emails = [...args.emails];
+  if (args.file) {
+    try {
+      const fileEmails = await readEmailsFromFile(args.file);
+      emails = [...emails, ...fileEmails];
+    } catch (err) {
+      const error = err;
+      console.error(`Error reading file: ${error.message}`);
+      process.exit(3);
+    }
+  }
+  if (emails.length === 0) {
+    console.error("Error: No email addresses provided");
+    console.error("Use --help for usage information");
+    process.exit(3);
+  }
+  const options = {
+    smtpTimeout: args.timeout,
+    verifySmtp: !args.noSmtp && !args.quick,
+    checkDisposable: !args.noDisposable,
+    checkRoleAccount: !args.noRole,
+    checkFreeProvider: !args.noFreeProvider,
+    checkGravatar: args.gravatar
+  };
+  try {
+    let results;
+    if (emails.length === 1) {
+      if (args.verbose) {
+        console.error(`Validating: ${emails[0]}`);
+      }
+      const result = args.quick ? await validateQuick(emails[0]) : await validate(emails[0], options);
+      results = [result];
+    } else {
+      if (args.verbose) {
+        console.error(`Validating ${emails.length} emails...`);
+      }
+      results = await validateBulk(emails, {
+        ...options,
+        concurrency: args.concurrency,
+        onProgress: args.verbose ? (completed, total, result) => {
+          console.error(`[${completed}/${total}] ${result.input}: ${result.isReachable}`);
+        } : void 0
+      });
+    }
+    const output = results.length === 1 ? formatResult(results[0], args.pretty) : JSON.stringify(results, null, args.pretty ? 2 : 0);
+    if (args.output) {
+      import_fs.default.writeFileSync(args.output, output + "\n");
+      if (args.verbose) {
+        console.error(`Results written to: ${args.output}`);
+      }
+    } else {
+      console.log(output);
+    }
+    process.exit(getExitCode(results));
+  } catch (err) {
+    const error = err;
+    console.error(`Error: ${error.message}`);
+    process.exit(3);
+  }
+}
+main().catch((err) => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(3);
+});