@mikkelscheike/email-provider-links 2.7.1 → 2.8.1

package/README.md

@@ -2,7 +2,11 @@
 
 🔒 **Modern email provider detection library with enhanced TypeScript support and enterprise security**
 
-A robust TypeScript library providing direct links to **93 email providers** (178 domains) with **concurrent DNS resolution**, **optimized performance**, **comprehensive email validation**, and advanced security features for login and password reset flows.
+A robust TypeScript library providing direct links to **93 email providers** (180 domains) with **concurrent DNS resolution**, **optimized performance**, **comprehensive email validation**, and advanced security features for login and password reset flows.
+
+## 🚀 Try it out
+
+**[Live Demo](https://demo.mikkelscheike.com)** - Test the library with any email address and see it in action!
 
 ## ✨ New in Version 2.7.0
 
@@ -13,12 +17,13 @@ A robust TypeScript library providing direct links to **93 email providers** (17
 - 🛡️ **Improved Security**: Enhanced cryptographic integrity verification
 - ⚡ **Better Performance**: Optimized concurrent DNS with smart caching
 - 🎯 **Developer Experience**: Enhanced error messages and debugging information
+- 📊 **Development Mode**: Memory usage tracking when NODE_ENV=development
 
 ## ✨ Core Features
 
-- 🚀 **Fast & Lightweight**: Zero dependencies, ultra-low memory (~0.39MB initial, ~0.02MB per 1000 ops)
+- 🚀 **Fast & Lightweight**: Zero dependencies, ultra-low memory (~0.08MB initial, ~0.03MB per 1000 ops)
 - 📧 **93 Email Providers**: Gmail, Outlook, Yahoo, ProtonMail, iCloud, and many more
-- 🌐 **178 Domains Supported**: Comprehensive international coverage
+- 🌐 **207 Domains Supported**: Comprehensive international coverage
 - 🌍 **Full IDN Support**: International domain names with RFC compliance and Punycode
 - ✅ **Advanced Email Validation**: International email validation with detailed error reporting
 - 🏢 **Business Domain Detection**: DNS-based detection for custom domains (Google Workspace, Microsoft 365, etc.)
@@ -31,7 +36,7 @@ A robust TypeScript library providing direct links to **93 email providers** (17
 - 🔄 **Email Alias Detection**: Normalize Gmail dots, plus addressing, and provider-specific aliases
 - 🛡️ **Fraud Prevention**: Detect duplicate accounts through email alias manipulation
 - 📦 **Batch Processing**: Efficiently process multiple emails with deduplication
-- 🧪 **Thoroughly Tested**: 396 tests with comprehensive code coverage
+- 🧪 **Thoroughly Tested**: 424 tests with 93.16% code coverage
 
 ## Installation
 
@@ -54,83 +59,9 @@ Fully compatible with the latest Node.js 24.x! The library is tested on:
 - Node.js 22.x (Current)
 - **Node.js 24.x (Latest)** - Full support with latest features
 
-## Quick Start
-
-**One function handles everything** - consumer emails, business domains, and unknown providers:
-
-```typescript
-import { getEmailProvider } from '@mikkelscheike/email-provider-links';
-
-// Works for ANY email address - the only function you need
-const result = await getEmailProvider('user@gmail.com');
-console.log(result.loginUrl);                    // "https://mail.google.com/mail/"
-console.log(result.provider?.companyProvider);   // "Gmail"
-
-// Automatically detects business domains too
-const business = await getEmailProvider('user@mycompany.com');
-console.log(business.provider?.companyProvider); // "Google Workspace" (if detected)
-
-// Gracefully handles unknown providers
-const unknown = await getEmailProvider('user@unknown.com');
-console.log(unknown.loginUrl);                   // null
-```
-
-## Enhanced Email Validation
-
-**New in 2.7.0**: Comprehensive email validation with international support:
-
-```typescript
-import { validateEmailAddress, validateInternationalEmail } from '@mikkelscheike/email-provider-links';
-
-// Enhanced validation with detailed error reporting
-const result = validateEmailAddress('user@example.com');
-if (result.isValid) {
-  console.log('Valid email:', result.normalizedEmail);
-} else {
-  console.log('Error:', result.error?.message);
-  console.log('Error code:', result.error?.code);
-}
-
-// International domain validation
-const intlResult = validateInternationalEmail('user@münchen.de');
-if (!intlResult) {
-  console.log('Valid international email');
-} else {
-  console.log('Validation error:', intlResult.message);
-}
-```
-
-## Batch Processing
-
-**New in 2.7.0**: Process multiple emails efficiently with deduplication:
-
-```typescript
-import { batchProcessEmails } from '@mikkelscheike/email-provider-links';
-
-const emails = [
-  'user@gmail.com',
-  'u.s.e.r+work@gmail.com',  // Alias of the first email
-  'test@yahoo.com',
-  'invalid-email'
-];
-
-const results = batchProcessEmails(emails, {
-  includeProviderInfo: true,
-  normalizeEmails: true,
-  deduplicateAliases: true
-});
-
-results.forEach(result => {
-  console.log(`${result.email}: ${result.isValid ? 'Valid' : 'Invalid'}`);
-  if (result.isDuplicate) {
-    console.log('  🔄 Duplicate detected');
-  }
-});
-```
-
 ## Supported Providers
 
-**📊 Current Coverage: 93 providers supporting 178 domains**
+**📊 Current Coverage: 93 providers supporting 207 domains**
 
 **Consumer Email Providers:**
 - **Gmail** (2 domains): gmail.com, googlemail.com
@@ -161,51 +92,53 @@ results.forEach(result => {
 
 ## API Reference
 
-### `getEmailProvider(email, timeout?)`
-**Recommended** - Detects any email provider including business domains.
+### Core Functions
+
+#### `getEmailProvider(email, timeout?)`
+**Recommended** - Complete provider detection with business domain support.
 
 ```typescript
-// 🚀 SAME CALL, DIFFERENT SCENARIOS:
-
-// ✅ For known providers (Gmail, Yahoo, etc.) - INSTANT response
-const gmail1 = await getEmailProvider('user@gmail.com');        // No timeout needed
-const gmail2 = await getEmailProvider('user@gmail.com', 3000);  // Same speed - timeout ignored
-// Both return instantly: { provider: "Gmail", loginUrl: "https://mail.google.com/mail/" }
-
-// 🔍 For business domains - DNS lookup required, timeout matters
-const biz1 = await getEmailProvider('user@mycompany.com');        // 5000ms timeout (default)
-const biz2 = await getEmailProvider('user@mycompany.com', 2000);  // 2000ms timeout (faster fail)
-const biz3 = await getEmailProvider('user@mycompany.com', 10000); // 10000ms timeout (slower networks)
-// All may detect: { provider: "Google Workspace", detectionMethod: "mx_record" }
-
-// 🎯 WHY USE CUSTOM TIMEOUT?
-// - Faster apps: Use 2000ms to fail fast on unknown domains
-// - Slower networks: Use 10000ms to avoid premature timeouts
-// - Enterprise: Use 1000ms for strict SLA requirements
+// Known providers (instant response)
+const result1 = await getEmailProvider('user@gmail.com');
+// Returns: { provider: "Gmail", loginUrl: "https://mail.google.com/mail/" }
+
+// Business domains (DNS lookup with timeout)
+const result2 = await getEmailProvider('user@company.com', 2000);
+// Returns: { provider: "Google Workspace", detectionMethod: "mx_record" }
 ```
 
-### `getEmailProviderSync(email)`
-**Synchronous** - Only checks predefined domains (no DNS lookup).
+#### `getEmailProviderSync(email)`
+**Fast** - Instant checks for known providers (no DNS lookup).
 
 ```typescript
-const result = getEmailProviderSync('user@gmail.com');
-// Returns: { provider, loginUrl, email }
+const result = getEmailProviderSync('user@outlook.com');
+// Returns: { provider: "Outlook", loginUrl: "https://outlook.live.com/" }
 ```
 
-### `getEmailProviderFast(email, options?)`
-**High-performance** - Concurrent DNS with detailed timing information.
+### Email Alias Support
+
+The library handles provider-specific email alias rules:
 
 ```typescript
-const result = await getEmailProviderFast('user@mycompany.com', {
-  enableParallel: true,
-  collectDebugInfo: true,
-  timeout: 3000
-});
-
-console.log(result.timing);    // { mx: 120, txt: 95, total: 125 }
-console.log(result.confidence); // 0.9
+// Gmail ignores dots and plus addressing
+emailsMatch('user.name+work@gmail.com', 'username@gmail.com') // true
+
+// Outlook preserves dots but ignores plus addressing
+emailsMatch('user.name+work@outlook.com', 'username@outlook.com') // false
+
+// Normalize emails to canonical form
+const canonical = normalizeEmail('u.s.e.r+tag@gmail.com');
+console.log(canonical); // 'user@gmail.com'
 ```
 
+**Provider Rules Overview**:
+- **Gmail**: Ignores dots, supports plus addressing
+- **Outlook**: Preserves dots, supports plus addressing
+- **Yahoo**: Preserves dots, supports plus addressing
+- **ProtonMail**: Preserves dots, supports plus addressing
+- **FastMail**: Preserves dots, supports plus addressing
+- **AOL**: Preserves everything except case
+
 ## Real-World Example
 
 ```typescript
@@ -301,93 +234,63 @@ console.log(domain); // 'example.com'
 
 </details>
 
-## TypeScript Support
-
-Full TypeScript support with comprehensive interfaces:
-
-```typescript
-interface EmailProviderResult {
-  provider: EmailProvider | null;
-  email: string;
-  loginUrl: string | null;
-  detectionMethod?: 'domain_match' | 'mx_record' | 'txt_record' | 'both' | 'proxy_detected';
-  proxyService?: string;
-  error?: {
-    type: 'INVALID_EMAIL' | 'DNS_TIMEOUT' | 'RATE_LIMITED' | 'UNKNOWN_DOMAIN' | 
-          'NETWORK_ERROR' | 'IDN_VALIDATION_ERROR';
-    message: string;
-    retryAfter?: number;  // seconds until retry allowed (for rate limiting)
-    idnError?: string;    // specific IDN validation error message
-  };
-}
-
-interface ConfigConstants {
-  DEFAULT_DNS_TIMEOUT: number;          // 5000ms
-  MAX_DNS_REQUESTS_PER_MINUTE: number;  // 10 requests
-  SUPPORTED_PROVIDERS_COUNT: number;    // 93 providers
-  SUPPORTED_DOMAINS_COUNT: number;      // 178 domains
-}
-```
-
-## 🛡️ Security Features
-
-This package implements **enterprise-grade security** to protect against malicious redirects and supply chain attacks:
+## Performance and Detection System
 
-### ✅ Multi-Layer Protection
+For detailed performance metrics and information about the detection system, refer to [Performance and Detection System](docs/PERFORMANCE.md).
 
-- **HTTPS-Only Enforcement**: All provider URLs must use HTTPS protocol
-- **Domain Allowlisting**: Only pre-approved domains are allowed (93+ verified providers)
-- **Malicious Pattern Detection**: Blocks IP addresses, URL shorteners, suspicious TLDs
-- **Path Traversal Prevention**: Detects and blocks `../` and encoded variants
-- **JavaScript Injection Protection**: Prevents `javascript:`, `data:`, and script injections
-- **File Integrity Verification**: SHA-256 hash verification for provider database
+### Development Mode Features
 
-### 🔒 Attack Prevention
+When `NODE_ENV` is set to 'development', the library provides additional insights:
 
-Protects against common attack vectors:
-- ❌ **URL Injection**: Blocked by strict allowlisting
-- ❌ **Typosquatting**: Blocked by domain validation
-- ❌ **URL Shorteners**: Blocked by pattern detection
-- ❌ **Protocol Downgrade**: Blocked by HTTPS enforcement
-- ❌ **Path Traversal**: Blocked by path validation
-- ❌ **Script Injection**: Blocked by content validation
-- ❌ **Supply Chain Attacks**: Blocked by integrity verification
-
-### 🧪 Security Testing
+```typescript
+// Memory usage is automatically logged:
+// 🚀 Current memory usage: 0.08 MB
+```
 
-- **396 comprehensive tests** covering all functionality and edge cases
-- **92+ dedicated security tests** covering all attack vectors
-- **Automated security validation** in CI/CD pipeline
-- **Regular security audits** of provider database
+### Memory Management
 
-## Performance Benchmarks
+The library implements careful memory management:
+- Initial load: ~0.08MB heap usage
+- Batch operations: ~0.03MB per 1000 operations
+- Maximum load: < 25MB even under heavy concurrent operations
+- Automatic garbage collection hints
+- Memory usage logging in development mode
 
-This package is designed to be extremely memory efficient and fast:
+### Performance Benchmarks
 
-- **Provider loading**: ~0.39MB heap usage, <0.5ms
-- **Email lookups**: ~0.02MB heap usage per 100 operations
-- **Concurrent DNS**: ~0.03MB heap usage, ~110ms for 10 lookups
-- **Large scale (1000 ops)**: ~0.02MB heap usage, <3ms total
-- **International validation**: <1ms for complex IDN domains
+Extensively optimized for both speed and memory efficiency:
 
-To run benchmarks locally:
-```bash
-npm run benchmark
-```
+**Speed Metrics**:
+- Initial provider load: ~0.5ms
+- Known provider lookup: <1ms
+- DNS-based detection: ~27ms average
+- Batch processing: 1000 operations in ~1.1ms
+- Email validation: <1ms for complex IDN domains
 
-## Examples
+**Memory Usage**:
+- Initial footprint: ~0.08MB
+- Per operation: ~0.03MB per 1000 lookups
+- Peak usage: <25MB under heavy load
+- Cache efficiency: >99% hit rate
+- Garbage collection: Automatic optimization
 
-Run the modern example to see all features in action:
+**Real-World Performance**:
+- 50,000+ operations/second for known providers
+- 100 concurrent DNS lookups in <1 second
+- Average latency: <1ms for cached lookups
+- Maximum latency: <5ms per lookup
 
+To run benchmarks:
 ```bash
-npx tsx examples/modern-example.ts
+npm run benchmark # Basic benchmarks
+node --expose-gc benchmark/memory.ts # Detailed memory analysis
 ```
 
 ## Contributing
 
 We welcome contributions! See [CONTRIBUTING.md](docs/CONTRIBUTING.md) for guidelines on adding new email providers.
 
-**Quality Assurance**: This project maintains high standards with 396 comprehensive tests achieving excellent code coverage.
+**Quality Assurance**: This project maintains high standards with 424 comprehensive tests achieving 93.16% code coverage (96.46% function coverage).
 **Security Note**: All new providers undergo security validation and must pass our allowlist verification.
 
 ## Security
@@ -400,4 +303,4 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ---
 
-**Zero dependencies • TypeScript-first • Production ready • International support**
+**Zero dependencies • TypeScript-first • Production ready • International support**

package/dist/alias-detection.js

@@ -9,184 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectEmailAlias = detectEmailAlias;
 exports.normalizeEmail = normalizeEmail;
 exports.emailsMatch = emailsMatch;
-/**
- * Email alias rules for major providers
- */
-const ALIAS_RULES = [
-    {
-        domains: ['gmail.com', 'googlemail.com'],
-        supportsPlusAddressing: true,
-        ignoresDots: true,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            // 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,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            // 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,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['fastmail.com', 'fastmail.fm'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['proton.me', 'protonmail.com', 'protonmail.ch', 'pm.me'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            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,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['zoho.com', 'zohomail.com', 'zoho.eu'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['icloud.com', 'me.com', 'mac.com'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['mail.com'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            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,
-        normalize: (email) => email.toLowerCase()
-    },
-    {
-        domains: ['mail.ru'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    },
-    {
-        domains: ['yandex.com', 'yandex.ru'],
-        supportsPlusAddressing: true,
-        ignoresDots: false,
-        normalize: (email) => {
-            const parts = email.toLowerCase().split('@');
-            const username = parts[0];
-            const domain = parts[1];
-            if (!username || !domain) {
-                return email.toLowerCase();
-            }
-            const cleanUsername = username.split('+')[0];
-            return `${cleanUsername}@${domain}`;
-        }
-    }
-];
+const loader_1 = require("./loader");
 /**
  * Validates email format
  */
@@ -194,12 +17,6 @@ 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())) || null;
-}
 /**
  * Detects and analyzes email aliases
  *
@@ -217,49 +34,61 @@ function detectEmailAlias(email) {
     if (!username || !domain) {
         throw new Error('Invalid email format - missing username or domain');
     }
-    const rule = getAliasRule(domain);
+    const { domainMap } = (0, loader_1.loadProviders)();
+    const provider = domainMap.get(domain);
     const result = {
         canonical: originalEmail.toLowerCase(),
         original: originalEmail,
         isAlias: false,
         aliasType: 'none'
     };
-    if (!rule) {
-        // No specific rule, just normalize case
-        result.canonical = originalEmail.toLowerCase();
+    if (!provider?.alias) {
         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;
+    let normalizedUsername = username;
+    let isAlias = false;
+    let aliasType = 'none';
+    let aliasPart;
+    // Handle case sensitivity (all modern providers are case-insensitive)
+    if (provider.alias?.case?.ignore) {
+        if (provider.alias.case?.strip) {
+            normalizedUsername = normalizedUsername.toLowerCase();
+        }
     }
-    // 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;
+    // Handle plus addressing (common for Gmail, Outlook, Yahoo, etc.)
+    if (provider.alias?.plus?.ignore) {
+        const plusIndex = username.indexOf('+');
+        if (plusIndex !== -1) {
+            aliasPart = username.substring(plusIndex + 1);
+            isAlias = true;
+            aliasType = 'plus';
+            if (provider.alias.plus?.strip) {
+                normalizedUsername = username.slice(0, plusIndex);
+            }
         }
     }
-    // Apply provider-specific normalization
-    if (rule.normalize) {
-        const normalized = rule.normalize(originalEmail);
-        if (normalized !== originalEmail.toLowerCase()) {
-            result.isAlias = true;
-            result.canonical = normalized;
+    // Handle dots (primarily for Gmail)
+    if (provider.alias?.dots?.ignore) {
+        const hasDots = username.includes('.');
+        if (hasDots) {
+            if (!isAlias) {
+                aliasPart = username;
+                isAlias = true;
+                aliasType = 'dot';
+            }
+            if (provider.alias.dots?.strip) {
+                normalizedUsername = normalizedUsername.replace(/\./g, '');
+            }
         }
     }
+    // Build the canonical form
+    result.canonical = `${normalizedUsername}@${domain}`;
+    result.isAlias = isAlias;
+    result.aliasType = aliasType;
+    if (aliasPart !== undefined) {
+        result.aliasPart = aliasPart;
+    }
     return result;
 }
 /**