@mikkelscheike/email-provider-links 1.6.0 → 1.7.0

package/README.md

@@ -1,14 +1,14 @@
 # Email Provider Links
 
-🔒 **Enterprise-grade secure email provider detection for login and password reset flows**
+🔒 **Enterprise-grade secure email provider detection with advanced alias normalization**
 
-A TypeScript package that provides direct links to email providers based on email addresses, with comprehensive security features to prevent malicious redirects and supply chain attacks.
+A TypeScript package providing direct links to **93 email providers** (180+ domains) with **email alias detection**, comprehensive security features, and international coverage for login and password reset flows.
 
 ## ✨ Features
 
 - 🚀 **Fast & Lightweight**: Zero dependencies, minimal footprint
-- 📧 **74 Email Providers**: Gmail, Outlook, Yahoo, ProtonMail, iCloud, and more
-- 🌐 **147+ Domains Supported**: Comprehensive international coverage
+- 📧 **93 Email Providers**: Gmail, Outlook, Yahoo, ProtonMail, iCloud, and many more
+- 🌐 **180+ Domains Supported**: Comprehensive international coverage
 - 🏢 **Business Domain Detection**: DNS-based detection for custom domains (Google Workspace, Microsoft 365, etc.)
 - 🔒 **Enterprise Security**: Multi-layer protection against malicious URLs and supply chain attacks
 - 🛡️ **URL Validation**: HTTPS-only enforcement with domain allowlisting
@@ -16,7 +16,9 @@ A TypeScript package that provides direct links to email providers based on emai
 - 📝 **Type Safe**: Full TypeScript support with comprehensive interfaces
 - ⚡ **Performance Optimized**: Smart DNS fallback with configurable timeouts
 - 🚦 **Rate Limiting**: Built-in DNS query rate limiting to prevent abuse
-- 🧪 **Thoroughly Tested**: 142+ tests with 94.69% code coverage
+- 🔄 **Email Alias Detection**: Normalize Gmail dots, plus addressing, and provider-specific aliases
+- 🛡️ **Fraud Prevention**: Detect duplicate accounts through email alias manipulation
+- 🧪 **Thoroughly Tested**: 188+ tests with comprehensive coverage
 
 ## Installation
 
@@ -40,7 +42,7 @@ console.log(business.provider?.companyProvider); // "Google Workspace" (if detec
 
 ## Supported Providers
 
-**📊 Current Coverage: 74 providers supporting 147+ domains**
+**📊 Current Coverage: 93 providers supporting 180+ domains**
 
 **Consumer Email Providers:**
 - **Gmail** (2 domains): gmail.com, googlemail.com
@@ -64,9 +66,10 @@ console.log(business.provider?.companyProvider); // "Google Workspace" (if detec
 - **Mailfence, SimpleLogin, AnonAddy**
 
 **International Providers:**
-- **Europe**: GMX, Web.de, Orange, Free.fr, T-Online, Libero
-- **Asia**: QQ Mail, NetEase, Sina Mail, Rakuten, Nifty, **Naver** (Korea), **Daum** (Korea), **Biglobe** (Japan)
-- **Other Regions**: UOL (Brazil), Telkom (South Africa), Xtra (New Zealand)
+- **Europe**: GMX, Web.de, Orange, Free.fr, T-Online, Libero, Virgilio, Telekom, Tiscali, Skynet, Telenet, Xs4All, Planet.nl, Bluewin, Eircom
+- **Asia**: QQ Mail, NetEase, Sina Mail, Alibaba Mail, Rakuten, Nifty, **Naver** (Korea), **Daum** (Korea), **Biglobe** (Japan), Sify, IndiatTimes (India)
+- **Eastern Europe**: Centrum (Czech/Slovak), Interia, Onet (Poland), Rambler (Russia)
+- **Other Regions**: UOL, Terra (Brazil), Telkom (South Africa), Xtra (New Zealand)
 
 ## API
 
@@ -100,6 +103,94 @@ async function handlePasswordReset(email: string) {
 }
 ```
 
+## 🔄 Email Alias Detection
+
+**NEW in v1.7.0** - Advanced email alias detection and normalization to prevent duplicate accounts and improve user experience.
+
+### Features
+
+- **Gmail Dot Normalization**: `u.s.e.r@gmail.com` → `user@gmail.com`
+- **Plus Addressing**: `user+newsletter@provider.com` → `user@provider.com`
+- **Provider-Specific Rules**: Different providers have different aliasing capabilities
+- **Fraud Prevention**: Detect when users try to create multiple accounts with aliases
+- **Email Deduplication**: Normalize email lists to get accurate unique user counts
+
+### Quick Start
+
+```typescript
+import { 
+  detectEmailAlias, 
+  normalizeEmail, 
+  emailsMatch 
+} from '@mikkelscheike/email-provider-links';
+
+// Detect and analyze aliases
+const result = detectEmailAlias('u.s.e.r+work@gmail.com');
+console.log(result.canonical);  // 'user@gmail.com'
+console.log(result.isAlias);    // true
+console.log(result.aliasType);  // 'plus'
+console.log(result.aliasPart);  // 'work'
+
+// Normalize any email to canonical form
+const canonical = normalizeEmail('U.S.E.R+Newsletter@GMAIL.COM');
+console.log(canonical); // 'user@gmail.com'
+
+// Check if two emails are the same person
+const match = emailsMatch('user@gmail.com', 'u.s.e.r+work@gmail.com');
+console.log(match); // true
+```
+
+### Provider Support
+
+| Provider | Plus Addressing | Dots Ignored | Example |
+|----------|----------------|--------------|----------|
+| **Gmail** | ✅ Yes | ✅ Yes | `u.s.e.r+tag@gmail.com` → `user@gmail.com` |
+| **Outlook** | ✅ Yes | ❌ No | `user+tag@outlook.com` → `user@outlook.com` |
+| **Yahoo** | ✅ Yes | ❌ No | `user+tag@yahoo.com` → `user@yahoo.com` |
+| **ProtonMail** | ✅ Yes | ❌ No | `user+tag@proton.me` → `user@proton.me` |
+| **AOL** | ❌ No | ❌ No | No aliasing support |
+
+### Advanced Usage
+
+```typescript
+// Prevent duplicate account creation
+async function registerUser(email: string) {
+  const canonical = normalizeEmail(email);
+  const existingUser = await findUserByEmail(canonical);
+  
+  if (existingUser) {
+    throw new Error('Email already registered');
+  }
+  
+  // Store canonical email to prevent future duplicates
+  await createUser({ email: canonical });
+}
+
+// Analyze email list for duplicates
+import { analyzeEmailAliases } from '@mikkelscheike/email-provider-links';
+
+const emailList = [
+  'user@gmail.com',
+  'u.s.e.r@gmail.com',
+  'user+newsletter@gmail.com',
+  'different@gmail.com'
+];
+
+const analysis = analyzeEmailAliases(emailList);
+console.log(analysis.totalEmails);      // 4
+console.log(analysis.uniqueCanonical);  // 2 (actual unique users)
+
+// Generate test aliases
+import { generateAliases } from '@mikkelscheike/email-provider-links';
+
+const aliases = generateAliases('user@gmail.com', {
+  plusAliases: ['work', 'personal'],
+  includeDotVariations: true,
+  maxDotVariations: 3
+});
+// Returns: ['user+work@gmail.com', 'user+personal@gmail.com', 'u.ser@gmail.com', ...]
+```
+
 ## Configuration
 
 ```typescript

package/dist/alias-detection.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Email Alias Detection Module
+ *
+ * Detects and normalizes email aliases across different providers.
+ * Supports plus addressing (+), dot variations, and provider-specific aliasing.
+ */
+export interface AliasDetectionResult {
+    /** The normalized/canonical email address */
+    canonical: string;
+    /** The original email address */
+    original: string;
+    /** Whether an alias was detected */
+    isAlias: boolean;
+    /** Type of alias detected */
+    aliasType: 'plus' | 'dot' | 'subdomain' | 'none';
+    /** The alias part (if any) */
+    aliasPart?: string;
+    /** The provider that supports this alias type */
+    provider?: string;
+}
+export interface AliasRule {
+    /** Email domains this rule applies to */
+    domains: string[];
+    /** Whether this provider supports plus addressing (user+alias@domain.com) */
+    supportsPlusAddressing: boolean;
+    /** Whether this provider ignores dots in username (user.name@domain.com = username@domain.com) */
+    ignoresDots: boolean;
+    /** Whether this provider supports subdomain aliases (user@alias.domain.com) */
+    supportsSubdomainAlias: boolean;
+    /** Custom alias patterns specific to this provider */
+    customPatterns?: RegExp[];
+    /** Function to normalize email for this provider */
+    normalize?: (email: string) => string;
+}
+/**
+ * Detects and analyzes email aliases
+ */
+export declare function detectEmailAlias(email: string): AliasDetectionResult;
+/**
+ * Normalizes an email address to its canonical form
+ */
+export declare function normalizeEmail(email: string): string;
+/**
+ * Checks if two email addresses are the same when normalized
+ */
+export declare function emailsMatch(email1: string, email2: string): boolean;
+/**
+ * Gets alias capabilities for a domain
+ */
+export declare function getAliasCapabilities(domain: string): AliasRule | null;
+/**
+ * Generates potential aliases for an email address
+ */
+export declare function generateAliases(email: string, options?: {
+    plusAliases?: string[];
+    includeDotVariations?: boolean;
+    maxDotVariations?: number;
+}): string[];
+/**
+ * Analyzes email aliasing patterns in a list of emails
+ */
+export declare function analyzeEmailAliases(emails: string[]): {
+    totalEmails: number;
+    uniqueCanonical: number;
+    aliasGroups: Array<{
+        canonical: string;
+        aliases: string[];
+        count: number;
+    }>;
+    providerStats: Record<string, {
+        total: number;
+        aliases: number;
+        types: Record<string, number>;
+    }>;
+};

package/dist/alias-detection.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Email Alias Detection Module
+ *
+ * Detects and normalizes email aliases across different providers.
+ * Supports plus addressing (+), dot variations, and provider-specific aliasing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEmailAlias = detectEmailAlias;
+exports.normalizeEmail = normalizeEmail;
+exports.emailsMatch = emailsMatch;
+exports.getAliasCapabilities = getAliasCapabilities;
+exports.generateAliases = generateAliases;
+exports.analyzeEmailAliases = analyzeEmailAliases;
+/**
+ * Email alias rules for major providers
+ */
+const ALIAS_RULES = [
+    {
+        domains: ['gmail.com', 'googlemail.com'],
+        supportsPlusAddressing: true,
+        ignoresDots: true,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            // Remove dots and everything after +
+            const cleanUsername = username.replace(/\./g, '').split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['outlook.com', 'hotmail.com', 'live.com', 'msn.com', 'hotmail.co.uk', 'hotmail.fr', 'hotmail.it', 'hotmail.es', 'hotmail.de', 'live.co.uk', 'live.fr', 'live.it', 'live.nl', 'live.com.au', 'live.ca', 'live.jp'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            // Only remove plus addressing for Outlook
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['yahoo.com', 'yahoo.co.uk', 'yahoo.fr', 'yahoo.co.in', 'yahoo.com.br', 'yahoo.co.jp', 'yahoo.it', 'yahoo.de', 'yahoo.in', 'yahoo.es', 'yahoo.ca', 'yahoo.com.au', 'yahoo.com.ar', 'yahoo.com.mx', 'yahoo.co.id', 'yahoo.com.sg', 'ymail.com', 'rocketmail.com'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['fastmail.com', 'fastmail.fm'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: true,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['proton.me', 'protonmail.com', 'protonmail.ch', 'pm.me'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['tutanota.com', 'tutanota.de', 'tutamail.com', 'tuta.io', 'keemail.me', 'tuta.com'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['zoho.com', 'zohomail.com', 'zoho.eu'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['icloud.com', 'me.com', 'mac.com'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['mail.com'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['aol.com', 'love.com', 'ygm.com', 'games.com', 'wow.com', 'aim.com'],
+        supportsPlusAddressing: false,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => email.toLowerCase()
+    },
+    {
+        domains: ['mail.ru'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    },
+    {
+        domains: ['yandex.com', 'yandex.ru'],
+        supportsPlusAddressing: true,
+        ignoresDots: false,
+        supportsSubdomainAlias: false,
+        normalize: (email) => {
+            const [username, domain] = email.toLowerCase().split('@');
+            const cleanUsername = username.split('+')[0];
+            return `${cleanUsername}@${domain}`;
+        }
+    }
+];
+/**
+ * Validates email format
+ */
+function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Gets the alias rule for a given domain
+ */
+function getAliasRule(domain) {
+    return ALIAS_RULES.find(rule => rule.domains.includes(domain.toLowerCase()));
+}
+/**
+ * Detects and analyzes email aliases
+ */
+function detectEmailAlias(email) {
+    if (!isValidEmail(email)) {
+        throw new Error('Invalid email format');
+    }
+    const originalEmail = email.trim();
+    const [username, domain] = originalEmail.toLowerCase().split('@');
+    const rule = getAliasRule(domain);
+    const result = {
+        canonical: originalEmail.toLowerCase(),
+        original: originalEmail,
+        isAlias: false,
+        aliasType: 'none'
+    };
+    if (!rule) {
+        // No specific rule, just normalize case
+        result.canonical = originalEmail.toLowerCase();
+        return result;
+    }
+    result.provider = domain;
+    // Check for plus addressing
+    if (rule.supportsPlusAddressing && username.includes('+')) {
+        const plusIndex = username.indexOf('+');
+        const baseUsername = username.substring(0, plusIndex);
+        const aliasPart = username.substring(plusIndex + 1);
+        result.isAlias = true;
+        result.aliasType = 'plus';
+        result.aliasPart = aliasPart;
+        result.canonical = rule.normalize ? rule.normalize(originalEmail) : `${baseUsername}@${domain}`;
+        return result;
+    }
+    // Check for dot variations (Gmail)
+    if (rule.ignoresDots && username.includes('.')) {
+        const baseUsername = username.replace(/\./g, '');
+        if (baseUsername !== username) {
+            result.isAlias = true;
+            result.aliasType = 'dot';
+            result.aliasPart = username;
+            result.canonical = rule.normalize ? rule.normalize(originalEmail) : `${baseUsername}@${domain}`;
+            return result;
+        }
+    }
+    // Apply provider-specific normalization
+    if (rule.normalize) {
+        const normalized = rule.normalize(originalEmail);
+        if (normalized !== originalEmail.toLowerCase()) {
+            result.isAlias = true;
+            result.canonical = normalized;
+        }
+    }
+    return result;
+}
+/**
+ * Normalizes an email address to its canonical form
+ */
+function normalizeEmail(email) {
+    const result = detectEmailAlias(email);
+    return result.canonical;
+}
+/**
+ * Checks if two email addresses are the same when normalized
+ */
+function emailsMatch(email1, email2) {
+    try {
+        return normalizeEmail(email1) === normalizeEmail(email2);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gets alias capabilities for a domain
+ */
+function getAliasCapabilities(domain) {
+    const rule = getAliasRule(domain.toLowerCase());
+    return rule ? { ...rule } : null;
+}
+/**
+ * Generates potential aliases for an email address
+ */
+function generateAliases(email, options = {}) {
+    if (!isValidEmail(email)) {
+        throw new Error('Invalid email format');
+    }
+    const [username, domain] = email.toLowerCase().split('@');
+    const rule = getAliasRule(domain);
+    const aliases = [];
+    if (!rule) {
+        return [email.toLowerCase()];
+    }
+    // Generate plus aliases
+    if (rule.supportsPlusAddressing && options.plusAliases) {
+        for (const alias of options.plusAliases) {
+            aliases.push(`${username}+${alias}@${domain}`);
+        }
+    }
+    // Generate dot variations (Gmail only)
+    if (rule.ignoresDots && options.includeDotVariations && username.length > 1) {
+        const maxVariations = Math.min(options.maxDotVariations ?? 5, username.length - 1);
+        const variations = new Set();
+        // Simple dot variations (insert dots between characters)
+        for (let i = 1; i < username.length && variations.size < maxVariations; i++) {
+            const withDot = username.slice(0, i) + '.' + username.slice(i);
+            variations.add(`${withDot}@${domain}`);
+        }
+        aliases.push(...Array.from(variations));
+    }
+    return aliases.length > 0 ? aliases : [email.toLowerCase()];
+}
+/**
+ * Analyzes email aliasing patterns in a list of emails
+ */
+function analyzeEmailAliases(emails) {
+    const canonicalMap = new Map();
+    const providerStats = {};
+    for (const email of emails) {
+        try {
+            const result = detectEmailAlias(email);
+            const canonical = result.canonical;
+            if (!canonicalMap.has(canonical)) {
+                canonicalMap.set(canonical, []);
+            }
+            canonicalMap.get(canonical).push(email);
+            // Update provider stats
+            if (result.provider) {
+                if (!providerStats[result.provider]) {
+                    providerStats[result.provider] = {
+                        total: 0,
+                        aliases: 0,
+                        types: {}
+                    };
+                }
+                providerStats[result.provider].total++;
+                if (result.isAlias) {
+                    providerStats[result.provider].aliases++;
+                    const type = result.aliasType;
+                    providerStats[result.provider].types[type] = (providerStats[result.provider].types[type] || 0) + 1;
+                }
+            }
+        }
+        catch {
+            // Skip invalid emails
+        }
+    }
+    const aliasGroups = Array.from(canonicalMap.entries()).map(([canonical, aliases]) => ({
+        canonical,
+        aliases,
+        count: aliases.length
+    })).sort((a, b) => b.count - a.count);
+    return {
+        totalEmails: emails.length,
+        uniqueCanonical: canonicalMap.size,
+        aliasGroups,
+        providerStats
+    };
+}

package/dist/index.d.ts

@@ -347,6 +347,10 @@ export declare const RateLimit: {
      */
     getCurrentLimiter: () => SimpleRateLimiter;
 };
+export * from './alias-detection';
+export * from './security/url-validator';
+export * from './security/hash-verifier';
+export * from './security/secure-loader';
 declare const _default: {
     getEmailProviderLink: typeof getEmailProviderLink;
     getEmailProviderLinkWithDNS: typeof getEmailProviderLinkWithDNS;

package/dist/index.js

@@ -11,6 +11,20 @@
  *
  * @packageDocumentation
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateLimit = void 0;
 exports.isValidEmail = isValidEmail;
@@ -592,6 +606,12 @@ exports.RateLimit = {
      */
     getCurrentLimiter: () => dnsRateLimiter
 };
+// Export alias detection module
+__exportStar(require("./alias-detection"), exports);
+// Export security modules
+__exportStar(require("./security/url-validator"), exports);
+__exportStar(require("./security/hash-verifier"), exports);
+__exportStar(require("./security/secure-loader"), exports);
 // Default export for convenience
 exports.default = {
     getEmailProviderLink,

package/dist/security/hash-verifier.js

@@ -27,9 +27,9 @@ const path_1 = require("path");
  */
 const KNOWN_GOOD_HASHES = {
     // SHA-256 hash of the legitimate emailproviders.json
-    'emailproviders.json': '1c7925d02cc66b487046afdce81f744bd7a42f5a489e16e53a1a979575e4473b',
+    'emailproviders.json': '41d2084580270f77ae2c2c5593995ebace7877a74f7d1c1e1bc7ed3b37611aa4',
     // You can add hashes for other critical files
-    'package.json': 'ba2810fd51f2d044890119e6f49926b80d822a4cafedaff25e3f91ba8ec65c2f'
+    'package.json': 'c73f9f005cc4204d321cb1382f80354e932dffc38804600cdcf307ef11a0525e'
 };
 /**
  * Calculates SHA-256 hash of a file or string content

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikkelscheike/email-provider-links",
-  "version": "1.6.0",
-  "description": "A TypeScript package providing direct links to 74 email providers (147+ domains) with enterprise security features, rate limiting, and comprehensive international coverage for login and password reset flows",
+  "version": "1.7.0",
+  "description": "A TypeScript package providing direct links to 93 email providers (180+ domains) with enterprise security features, email alias detection, rate limiting, and comprehensive international coverage for login and password reset flows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -30,6 +30,11 @@
     "gmail",
     "outlook",
     "yahoo",
+    "alias-detection",
+    "email-normalization",
+    "plus-addressing",
+    "fraud-prevention",
+    "deduplication",
     "typescript",
     "npm",
     "utility"

package/providers/emailproviders.json

@@ -853,6 +853,161 @@
       "domains": [
         "zoho.eu"
       ]
+    },
+    {
+      "companyProvider": "Alibaba Mail",
+      "loginUrl": "https://mail.aliyun.com",
+      "domains": [
+        "aliyun.com",
+        "alibaba.com",
+        "taobao.com",
+        "tmall.com"
+      ],
+      "customDomainDetection": {
+        "mxPatterns": [
+          "mx1.qiye.aliyun.com",
+          "mx2.qiye.aliyun.com",
+          "mx3.qiye.aliyun.com"
+        ],
+        "txtPatterns": [
+          "v=spf1 include:spf.qiye.aliyun.com"
+        ]
+      }
+    },
+    {
+      "companyProvider": "Sify Mail",
+      "loginUrl": "https://mail.sify.com",
+      "domains": [
+        "sify.com",
+        "sifymail.com"
+      ]
+    },
+    {
+      "companyProvider": "IndiatTimes Mail",
+      "loginUrl": "https://mail.indiatimes.com",
+      "domains": [
+        "indiatimes.com"
+      ]
+    },
+    {
+      "companyProvider": "Virgilio Mail",
+      "loginUrl": "https://mail.virgilio.it",
+      "domains": [
+        "virgilio.it",
+        "alice.it",
+        "tin.it"
+      ]
+    },
+    {
+      "companyProvider": "Telekom Mail",
+      "loginUrl": "https://email.magenta.de",
+      "domains": [
+        "magenta.de",
+        "telekom.de"
+      ]
+    },
+    {
+      "companyProvider": "Tiscali Mail",
+      "loginUrl": "https://mail.tiscali.it",
+      "domains": [
+        "tiscali.it"
+      ]
+    },
+    {
+      "companyProvider": "Skynet Mail",
+      "loginUrl": "https://webmail.skynet.be",
+      "domains": [
+        "skynet.be"
+      ]
+    },
+    {
+      "companyProvider": "Telenet Mail",
+      "loginUrl": "https://webmail.telenet.be",
+      "domains": [
+        "telenet.be"
+      ]
+    },
+    {
+      "companyProvider": "Xs4All",
+      "loginUrl": "https://webmail.xs4all.nl",
+      "domains": [
+        "xs4all.nl"
+      ]
+    },
+    {
+      "companyProvider": "Planet.nl",
+      "loginUrl": "https://webmail.planet.nl",
+      "domains": [
+        "planet.nl"
+      ]
+    },
+    {
+      "companyProvider": "Bluewin Mail",
+      "loginUrl": "https://webmail.bluewin.ch",
+      "domains": [
+        "bluewin.ch"
+      ]
+    },
+    {
+      "companyProvider": "Eircom Mail",
+      "loginUrl": "https://webmail.eircom.net",
+      "domains": [
+        "eircom.net"
+      ]
+    },
+    {
+      "companyProvider": "Centrum Mail",
+      "loginUrl": "https://www.centrum.cz",
+      "domains": [
+        "centrum.cz",
+        "centrum.sk"
+      ]
+    },
+    {
+      "companyProvider": "Interia Mail",
+      "loginUrl": "https://poczta.interia.pl",
+      "domains": [
+        "interia.pl"
+      ]
+    },
+    {
+      "companyProvider": "Onet Mail",
+      "loginUrl": "https://poczta.onet.pl",
+      "domains": [
+        "onet.pl",
+        "poczta.onet.pl",
+        "op.pl"
+      ]
+    },
+    {
+      "companyProvider": "Rambler Mail",
+      "loginUrl": "https://mail.rambler.ru",
+      "domains": [
+        "rambler.ru",
+        "lenta.ru",
+        "autorambler.ru"
+      ]
+    },
+    {
+      "companyProvider": "Nate Mail",
+      "loginUrl": "https://mail.nate.com",
+      "domains": [
+        "nate.com"
+      ]
+    },
+    {
+      "companyProvider": "Hanmail",
+      "loginUrl": "https://mail.hanmail.net",
+      "domains": [
+        "hanmail.net"
+      ]
+    },
+    {
+      "companyProvider": "Live.jp",
+      "loginUrl": "https://login.live.com",
+      "domains": [
+        "live.jp"
+      ]
     }
   ]
-}
+}