@emailcheck/email-validator-js 3.2.0 → 3.4.0

package/README.md

@@ -390,28 +390,28 @@ const name = detectNameFromEmail({
 #### `defaultNameDetectionMethod(email: string): DetectedName | null`
 The default name detection implementation, exported for custom extensions.
 
-#### Algrothin-Specific Name Cleaning
+#### Algorithm-Specific Name Cleaning
 
-##### `cleanNameForAlgrothin(name: string): string`
-Clean a name by removing special characters (dots, underscores, asterisks). Specifically designed for Algrothin name processing.
+##### `cleanNameForAlgorithm(name: string): string`
+Clean a name by removing special characters (dots, underscores, asterisks). Specifically designed for Algorithm name processing.
 
 ```typescript
-import { cleanNameForAlgrothin } from '@emailcheck/email-validator-js';
+import { cleanNameForAlgorithm } from '@emailcheck/email-validator-js';
 
-const cleanedName = cleanNameForAlgrothin('john.doe_smith*');
+const cleanedName = cleanNameForAlgorithm('john.doe_smith*');
 // Returns: 'johndoesmith'
 
-const cleanedName2 = cleanNameForAlgrothin('first_name.last');
+const cleanedName2 = cleanNameForAlgorithm('first_name.last');
 // Returns: 'firstnamelast'
 ```
 
-##### `detectNameForAlgrothin(email: string): DetectedName | null`
-Enhanced name detection for Algrothin with aggressive cleaning. Removes dots, underscores, and asterisks from detected names.
+##### `detectNameForAlgorithm(email: string): DetectedName | null`
+Enhanced name detection for Algorithm with aggressive cleaning. Removes dots, underscores, and asterisks from detected names.
 
 ```typescript
-import { detectNameForAlgrothin } from '@emailcheck/email-validator-js';
+import { detectNameForAlgorithm } from '@emailcheck/email-validator-js';
 
-const result = detectNameForAlgrothin('john.doe_smith@company.com');
+const result = detectNameForAlgorithm('john.doe_smith@company.com');
 // Returns: { firstName: 'John', lastName: 'Doesmith', confidence: 0.9025 }
 
 // Compared to regular detection:

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export * from './cache';
 export * from './cache-interface';
 export { commonEmailDomains, defaultDomainSuggestionMethod, getDomainSimilarity, isCommonDomain, suggestDomain, suggestEmailDomain, } from './domain-suggester';
 export { isValidEmail, isValidEmailDomain } from './email-validator';
+export { isSpamEmail, isSpamEmailLocalPart } from './is-spam-email';
+export { isSpamName } from './is-spam-name';
 export { cleanNameForAlgorithm, defaultNameDetectionMethod, detectName, detectNameForAlgorithm, detectNameFromEmail, } from './name-detector';
 export * from './types';
 export { getDomainAge, getDomainRegistrationStatus } from './whois';

package/dist/index.esm.js

@@ -1332,11 +1332,10 @@ function isIPAddress(host) {
   const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}$|^(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}$|^(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}$|^[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})$|^::1(?::(?::[0-9a-fA-F]{1,4}){1,7})|$|:(?:(?::[0-9a-fA-F]{1,4}){1,7}:)$/;
   return ipv6Regex.test(host);
 }
+function isHighVolume(smtpReply) {
+  return Boolean(smtpReply && /high number of/gi.test(smtpReply));
+}
 function isOverQuota(smtpReply) {
-  var _a;
-  if ((_a = smtpReply === null || smtpReply === void 0 ? void 0 : smtpReply.toLowerCase()) === null || _a === void 0 ? void 0 : _a.includes("excessively high number of invalid recipients")) {
-    return true;
-  }
   return Boolean(smtpReply && /(over quota)/gi.test(smtpReply));
 }
 function isInvalidMailboxError(smtpReply) {
@@ -1568,7 +1567,7 @@ async function testSMTPConnection(params) {
           sendCommand("STARTTLS");
           break;
         case SMTPStep.mailFrom: {
-          const from = activeSequence.from || "<>";
+          const from = activeSequence.from || `<${local}@${domain}>`;
           sendCommand(`MAIL FROM:${from}`);
           break;
         }
@@ -1594,6 +1593,10 @@ async function testSMTPConnection(params) {
       if (isMultilineGreet(response)) {
         return;
       }
+      if (isHighVolume(response)) {
+        finish(true, "high_volume");
+        return;
+      }
       if (isOverQuota(response)) {
         finish(false, "over_quota");
         return;
@@ -2643,6 +2646,99 @@ function createErrorResult(email, _error) {
   };
 }
 
+function isSpamEmail(email) {
+  if (typeof email !== "string")
+    return false;
+  const atIndex = email.lastIndexOf("@");
+  if (atIndex === -1)
+    return false;
+  const localPart = email.slice(0, atIndex);
+  if (localPart.length < 16)
+    return false;
+  const cleaned = localPart.replace(/[._+-]/g, "");
+  if (cleaned.length < 12)
+    return false;
+  if (!/^[A-Za-z0-9]+$/.test(cleaned))
+    return false;
+  const lettersOnly = cleaned.replace(/[0-9]/g, "");
+  if (lettersOnly.length < 10)
+    return false;
+  function vowelRatio(str) {
+    const vowels = (str.match(/[aeiouAEIOU]/g) || []).length;
+    return vowels / str.length;
+  }
+  function uppercaseRatio(str) {
+    const uppercase = (str.match(/[A-Z]/g) || []).length;
+    return uppercase / str.length;
+  }
+  function hasRepeatedPatterns(str) {
+    const patterns = /(.)\1{2,}/g;
+    const matches = str.match(patterns);
+    return matches !== null && matches.length > 0;
+  }
+  function hasConsonantClusters(str) {
+    const clusters = str.match(/[^aeiouAEIOU]{3,}/g);
+    return clusters !== null && clusters.length > 0;
+  }
+  function hasAlternatingCase(str) {
+    if (str.length < 8)
+      return false;
+    let alternatingChanges = 0;
+    for (let i = 1; i < str.length; i++) {
+      const prevIsUpper = str[i - 1] >= "A" && str[i - 1] <= "Z";
+      const currIsUpper = str[i] >= "A" && str[i] <= "Z";
+      if (prevIsUpper !== currIsUpper) {
+        alternatingChanges++;
+      }
+    }
+    return alternatingChanges / str.length > 0.7;
+  }
+  const vowelR = vowelRatio(lettersOnly);
+  const upperR = uppercaseRatio(lettersOnly);
+  if (hasAlternatingCase(lettersOnly))
+    return true;
+  if (vowelR > 0.35)
+    return false;
+  if (upperR < 0.15)
+    return false;
+  if (hasRepeatedPatterns(localPart))
+    return true;
+  if (hasConsonantClusters(lettersOnly))
+    return true;
+  if (cleaned.length >= 20 && vowelR < 0.25)
+    return true;
+  return true;
+}
+function isSpamEmailLocalPart(email) {
+  return isSpamEmail(email);
+}
+
+function isSpamName(name) {
+  if (typeof name !== "string")
+    return false;
+  const cleaned = name.replace(/[,.;:!?]+$/, "").trim();
+  const parts = cleaned.split(/\s+/);
+  if (parts.length !== 2)
+    return false;
+  const [first, second] = parts;
+  if (!/^[A-Za-z]+$/.test(first) || !/^[A-Za-z]+$/.test(second))
+    return false;
+  if (first.length < 16 || second.length < 16)
+    return false;
+  function vowelRatio(str) {
+    const vowels = (str.match(/[aeiouAEIOU]/g) || []).length;
+    return vowels / str.length;
+  }
+  const ratio1 = vowelRatio(first);
+  const ratio2 = vowelRatio(second);
+  const avgRatio = (ratio1 + ratio2) / 2;
+  if (avgRatio > 0.35 && ratio1 > 0.25 && ratio2 > 0.25)
+    return false;
+  if (!/[A-Z]/.test(first) || !/[A-Z]/.test(second))
+    return false;
+  return true;
+}
+
 let disposableEmailProviders;
 let freeEmailProviders;
 async function isDisposableEmail(params) {
@@ -2918,5 +3014,5 @@ async function verifyEmail(params) {
   return result;
 }
 
-export { DEFAULT_CACHE_OPTIONS, EmailProvider, LRUAdapter, RedisAdapter, SMTPStep, VerificationErrorCode, cleanNameForAlgorithm, clearDefaultCache, commonEmailDomains, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgorithm, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, parseSmtpError, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
+export { DEFAULT_CACHE_OPTIONS, EmailProvider, LRUAdapter, RedisAdapter, SMTPStep, VerificationErrorCode, cleanNameForAlgorithm, clearDefaultCache, commonEmailDomains, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgorithm, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isSpamEmail, isSpamEmailLocalPart, isSpamName, isValidEmail, isValidEmailDomain, parseSmtpError, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
 //# sourceMappingURL=index.esm.js.map