@mikkelscheike/email-provider-links 4.0.11 → 5.1.0

package/dist/provider-loader.js

@@ -10,47 +10,29 @@ exports.clearCache = clearCache;
 exports.loadProviders = loadProviders;
 exports.initializeSecurity = initializeSecurity;
 exports.createSecurityMiddleware = createSecurityMiddleware;
-const fs_1 = require("fs");
+exports.buildDomainMap = buildDomainMap;
+exports.getLoadingStats = getLoadingStats;
+exports.loadProvidersDebug = loadProvidersDebug;
 const path_1 = require("path");
+const fs_1 = require("fs");
 const url_validator_1 = require("./url-validator");
 const hash_verifier_1 = require("./hash-verifier");
-const schema_1 = require("./schema");
+const error_utils_1 = require("./error-utils");
+const constants_1 = require("./constants");
+const provider_store_1 = require("./provider-store");
 // Cache for load results
 let cachedLoadResult = null;
+// Cache for loading statistics
+let loadingStats = null;
+// Cache for domain maps
+let cachedDomainMap = null;
 /**
  * Clear the cache (useful for testing or when providers file changes)
  */
 function clearCache() {
     cachedLoadResult = null;
-}
-/**
- * Convert compressed provider to EmailProvider format
- */
-function convertProviderToEmailProvider(compressedProvider) {
-    if (!compressedProvider.type) {
-        console.warn(`Missing type for provider ${compressedProvider.id}`);
-    }
-    const provider = {
-        companyProvider: compressedProvider.companyProvider,
-        loginUrl: compressedProvider.loginUrl || null,
-        domains: compressedProvider.domains || [],
-        type: compressedProvider.type,
-        alias: compressedProvider.alias
-    };
-    // Include DNS detection patterns for business email services and proxy services
-    const needsCustomDomainDetection = compressedProvider.type === 'custom_provider' ||
-        compressedProvider.type === 'proxy_service';
-    if (needsCustomDomainDetection && (compressedProvider.mx?.length || compressedProvider.txt?.length)) {
-        provider.customDomainDetection = {};
-        if (compressedProvider.mx?.length) {
-            provider.customDomainDetection.mxPatterns = compressedProvider.mx;
-        }
-        if (compressedProvider.txt?.length) {
-            // Decompress TXT patterns
-            provider.customDomainDetection.txtPatterns = compressedProvider.txt.map(schema_1.decompressTxtPattern);
-        }
-    }
-    return provider;
+    loadingStats = null;
+    cachedDomainMap = null;
 }
 /**
  * Loads and validates email provider data with security checks
@@ -83,39 +65,62 @@ function loadProviders(providersPath, expectedHash) {
     }
     // Step 2: Load and parse JSON
     try {
-        const fileContent = (0, fs_1.readFileSync)(filePath, 'utf8');
-        const data = JSON.parse(fileContent);
-        // Validate format
-        if (!data.version || !data.providers || !Array.isArray(data.providers)) {
-            throw new Error('Invalid provider data format');
+        const { data } = (0, provider_store_1.readProvidersDataFile)(filePath);
+        providers = data.providers.map(provider_store_1.convertProviderToEmailProviderShared);
+        // Log memory usage in development mode
+        if (process.env.NODE_ENV === 'development' && !process.env.JEST_WORKER_ID) {
+            const memUsage = process.memoryUsage();
+            const memUsageMB = (memUsage.heapUsed / constants_1.MemoryConstants.BYTES_PER_KB / constants_1.MemoryConstants.KB_PER_MB).toFixed(2);
+            console.log(`🚀 Current memory usage: ${memUsageMB} MB`);
         }
-        // Convert to EmailProvider format
-        providers = data.providers.map(convertProviderToEmailProvider);
     }
     catch (error) {
-        issues.push(`Failed to load providers file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        return {
-            success: false,
-            providers: [],
-            securityReport: {
-                hashVerification: false,
-                urlValidation: false,
-                totalProviders: 0,
-                validUrls: 0,
-                invalidUrls: 0,
-                securityLevel: 'CRITICAL',
-                issues
+        // Use standardized error handling utilities
+        const errorMessage = (0, error_utils_1.getErrorMessage)(error);
+        const fileNotFound = (0, error_utils_1.isFileNotFoundError)(error);
+        const jsonError = (0, error_utils_1.isJsonError)(error);
+        // Return error result for JSON parse errors and file not found (ENOENT)
+        // This allows security tests to check error handling
+        // Note: ENOENT errors are already handled by hash verification, but we still need to handle
+        // them here in case hash verification passed but file was deleted between verification and read
+        if (jsonError || fileNotFound) {
+            if (!jsonError) {
+                // For file not found, don't add duplicate issue if hash verification already failed
+                if (hashResult.isValid) {
+                    issues.push(`Failed to load providers file: ${errorMessage}`);
+                }
             }
-        };
+            else {
+                issues.push(`Failed to load providers file: ${errorMessage}`);
+            }
+            return {
+                success: false,
+                providers: [],
+                securityReport: {
+                    hashVerification: hashResult.isValid,
+                    urlValidation: false,
+                    totalProviders: 0,
+                    validUrls: 0,
+                    invalidUrls: 0,
+                    securityLevel: 'CRITICAL',
+                    issues
+                }
+            };
+        }
+        // For other errors, add to issues and throw (to match loader.test.ts expectations)
+        issues.push(`Failed to load providers file: ${errorMessage}`);
+        throw new Error(`Failed to load provider data: ${errorMessage}`);
     }
     // Step 3: URL validation audit
     const urlAudit = (0, url_validator_1.auditProviderSecurity)(providers);
-    if (urlAudit.invalid > 0) {
-        issues.push(`${urlAudit.invalid} providers have invalid URLs`);
+    // Count only providers with invalid URLs (not providers without URLs)
+    const providersWithInvalidUrls = urlAudit.invalidProviders.filter(invalid => invalid.url !== '' && invalid.url !== undefined && invalid.url !== null);
+    if (providersWithInvalidUrls.length > 0) {
+        issues.push(`${providersWithInvalidUrls.length} providers have invalid URLs`);
         // Suppress logging during tests to avoid console noise
         if (process.env.NODE_ENV !== 'test' && !process.env.JEST_WORKER_ID) {
             console.warn('⚠️  URL validation issues found:');
-            for (const invalid of urlAudit.invalidProviders) {
+            for (const invalid of providersWithInvalidUrls) {
                 console.warn(`- ${invalid.provider}: ${invalid.validation.reason}`);
             }
         }
@@ -132,28 +137,39 @@ function loadProviders(providersPath, expectedHash) {
         issues.push(`Filtered out ${filtered} providers with invalid URLs`);
     }
     // Step 5: Determine security level
+    // Only providers with invalid URLs affect security level, not providers without URLs
     let securityLevel = 'SECURE';
     if (!hashResult.isValid) {
         securityLevel = 'CRITICAL';
     }
-    else if (urlAudit.invalid > 0 || issues.length > 0) {
+    else if (providersWithInvalidUrls.length > 0 || issues.length > 0) {
         securityLevel = 'WARNING';
     }
     const loadResult = {
         success: securityLevel !== 'CRITICAL',
         providers: secureProviders,
+        domainMap: buildDomainMap(secureProviders),
+        stats: {
+            loadTime: 0, // Would need to track this during load
+            domainMapTime: 0,
+            providerCount: secureProviders.length,
+            domainCount: secureProviders.reduce((count, p) => count + (p.domains?.length || 0), 0),
+            fileSize: (0, fs_1.readFileSync)(filePath, 'utf8').length // Calculate actual file size in bytes
+        },
         securityReport: {
             hashVerification: hashResult.isValid,
-            urlValidation: urlAudit.invalid === 0,
+            urlValidation: providersWithInvalidUrls.length === 0, // Only count providers with invalid URLs, not providers without URLs
             totalProviders: providers.length,
             validUrls: urlAudit.valid,
-            invalidUrls: urlAudit.invalid,
+            invalidUrls: providersWithInvalidUrls.length, // Only count actual invalid URLs
             securityLevel,
             issues
         }
     };
     // Cache the result for future calls
     cachedLoadResult = loadResult;
+    // Update loading stats for getLoadingStats()
+    loadingStats = loadResult.stats;
     return loadResult;
 }
 /**
@@ -178,19 +194,79 @@ function createSecurityMiddleware(options = {}) {
             if (options.onSecurityIssue) {
                 options.onSecurityIssue(result.securityReport);
             }
-            return res.status(500).json({
+            res.status(500).json({
                 error: 'Security validation failed',
                 details: result.securityReport
             });
+            return;
         }
         // Attach secure providers to request
         req.secureProviders = result.providers;
         req.securityReport = result.securityReport;
         next();
+        return;
+    };
+}
+/**
+ * Build domain map from providers
+ */
+function buildDomainMap(providers) {
+    // Return cached domain map if available
+    if (cachedDomainMap) {
+        return cachedDomainMap;
+    }
+    // Build and cache the domain map
+    cachedDomainMap = (0, provider_store_1.buildDomainMapShared)(providers);
+    return cachedDomainMap;
+}
+/**
+ * Get loading statistics from the last load operation
+ */
+function getLoadingStats() {
+    return loadingStats;
+}
+/**
+ * Load providers with debug information (always reloads cache)
+ */
+function loadProvidersDebug() {
+    const startTime = process.hrtime.bigint();
+    // Clear cache for debug mode - ensure we always reload
+    cachedLoadResult = null;
+    loadingStats = null;
+    const result = loadProviders();
+    const endTime = process.hrtime.bigint();
+    // Build domain map and calculate stats
+    const domainMapStart = process.hrtime.bigint();
+    const domainMap = buildDomainMap(result.providers);
+    const domainMapEnd = process.hrtime.bigint();
+    // Store loading stats
+    loadingStats = {
+        loadTime: Number(endTime - startTime) / 1000000, // Convert to milliseconds
+        domainMapTime: Number(domainMapEnd - domainMapStart) / 1000000,
+        providerCount: result.providers.length,
+        domainCount: domainMap.size,
+        fileSize: 0 // Would need to track this during load
+    };
+    // Debug output
+    console.log('=== Provider Loading Debug ===');
+    console.log(`Providers loaded: ${result.providers.length}`);
+    console.log(`Security level: ${result.securityReport.securityLevel}`);
+    console.log(`Load time: ${loadingStats.loadTime.toFixed(2)}ms`);
+    console.log(`Domain map time: ${loadingStats.domainMapTime.toFixed(2)}ms`);
+    console.log(`Total domains: ${loadingStats.domainCount}`);
+    console.log('=============================');
+    // Return enhanced result with debug info - ensure new objects each time
+    return {
+        ...result,
+        domainMap: new Map(domainMap), // Create new Map instance
+        stats: { ...loadingStats } // Create new stats object
     };
 }
 exports.default = {
     loadProviders,
+    loadProvidersDebug,
+    buildDomainMap,
+    getLoadingStats,
     initializeSecurity,
     createSecurityMiddleware,
     clearCache

package/dist/provider-store.d.ts

@@ -0,0 +1,9 @@
+import type { EmailProvider } from './api';
+import { Provider, ProvidersData } from './schema';
+export declare function convertProviderToEmailProviderShared(compressedProvider: Provider): EmailProvider;
+export declare function readProvidersDataFile(filePath: string): {
+    data: ProvidersData;
+    fileSize: number;
+};
+export declare function buildDomainMapShared(providers: EmailProvider[]): Map<string, EmailProvider>;
+//# sourceMappingURL=provider-store.d.ts.map

package/dist/provider-store.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertProviderToEmailProviderShared = convertProviderToEmailProviderShared;
+exports.readProvidersDataFile = readProvidersDataFile;
+exports.buildDomainMapShared = buildDomainMapShared;
+const fs_1 = require("fs");
+const schema_1 = require("./schema");
+function convertProviderToEmailProviderShared(compressedProvider) {
+    if (!compressedProvider.type) {
+        console.warn(`Missing type for provider ${compressedProvider.id}`);
+    }
+    const provider = {
+        companyProvider: compressedProvider.companyProvider,
+        loginUrl: compressedProvider.loginUrl || null,
+        domains: compressedProvider.domains || [],
+        type: compressedProvider.type,
+        alias: compressedProvider.alias
+    };
+    const needsCustomDomainDetection = compressedProvider.type === 'custom_provider' ||
+        compressedProvider.type === 'proxy_service';
+    if (needsCustomDomainDetection && (compressedProvider.mx?.length || compressedProvider.txt?.length)) {
+        provider.customDomainDetection = {};
+        if (compressedProvider.mx?.length) {
+            provider.customDomainDetection.mxPatterns = compressedProvider.mx;
+        }
+        if (compressedProvider.txt?.length) {
+            provider.customDomainDetection.txtPatterns = compressedProvider.txt.map(schema_1.decompressTxtPattern);
+        }
+    }
+    return provider;
+}
+function readProvidersDataFile(filePath) {
+    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+    const data = JSON.parse(content);
+    if (!data.version || !data.providers || !Array.isArray(data.providers)) {
+        throw new Error('Invalid provider data format');
+    }
+    return { data, fileSize: content.length };
+}
+function buildDomainMapShared(providers) {
+    const domainMap = new Map();
+    for (const provider of providers) {
+        for (const domain of provider.domains) {
+            domainMap.set(domain.toLowerCase(), provider);
+        }
+    }
+    return domainMap;
+}
+//# sourceMappingURL=provider-store.js.map

package/dist/url-validator.d.ts

@@ -4,6 +4,15 @@
  * Provides validation and allowlisting for email provider URLs to prevent
  * malicious redirects and supply chain attacks.
  */
+/**
+ * Get allowlisted domains from provider data
+ * Only URLs from these domains will be considered safe.
+ */
+export declare function getAllowedDomains(): Set<string>;
+type ProviderUrlLike = {
+    companyProvider?: string;
+    loginUrl?: string | null;
+};
 export interface URLValidationResult {
     isValid: boolean;
     reason?: string;
@@ -23,7 +32,7 @@ export declare function validateEmailProviderUrl(url: string): URLValidationResu
  * @param providers - Array of email providers to validate
  * @returns Array of validation results
  */
-export declare function validateAllProviderUrls(providers: any[]): Array<{
+export declare function validateAllProviderUrls(providers: ProviderUrlLike[]): Array<{
     provider: string;
     url: string;
     validation: URLValidationResult;
@@ -34,7 +43,7 @@ export declare function validateAllProviderUrls(providers: any[]): Array<{
  * @param providers - Array of email providers to audit
  * @returns Security audit report
  */
-export declare function auditProviderSecurity(providers: any[]): {
+export declare function auditProviderSecurity(providers: ProviderUrlLike[]): {
     total: number;
     valid: number;
     invalid: number;
@@ -45,4 +54,5 @@ export declare function auditProviderSecurity(providers: any[]): {
     }[];
     report: string;
 };
+export {};
 //# sourceMappingURL=url-validator.d.ts.map

package/dist/url-validator.js

@@ -6,22 +6,35 @@
  * malicious redirects and supply chain attacks.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowedDomains = getAllowedDomains;
 exports.validateEmailProviderUrl = validateEmailProviderUrl;
 exports.validateAllProviderUrls = validateAllProviderUrls;
 exports.auditProviderSecurity = auditProviderSecurity;
-const loader_1 = require("./loader");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const hash_verifier_1 = require("./hash-verifier");
 /**
  * Get allowlisted domains from provider data
  * Only URLs from these domains will be considered safe.
  */
 function getAllowedDomains() {
-    const { providers } = (0, loader_1.loadProviders)();
+    const filePath = (0, path_1.join)(__dirname, '..', 'providers', 'emailproviders.json');
+    const integrity = (0, hash_verifier_1.verifyProvidersIntegrity)(filePath);
+    if (!integrity.isValid) {
+        return new Set();
+    }
+    if (cachedAllowedDomains && cachedAllowlistHash === integrity.actualHash) {
+        return cachedAllowedDomains;
+    }
+    const fileContent = (0, fs_1.readFileSync)(filePath, 'utf8');
+    const data = JSON.parse(fileContent);
+    const providers = data.providers;
     const allowedDomains = new Set();
     for (const provider of providers) {
         if (provider.loginUrl) {
             try {
                 const url = new URL(provider.loginUrl);
-                allowedDomains.add(url.hostname);
+                allowedDomains.add((0, idn_1.domainToPunycode)(url.hostname.toLowerCase()));
             }
             catch {
                 // Skip invalid URLs
@@ -29,8 +42,12 @@ function getAllowedDomains() {
             }
         }
     }
+    cachedAllowedDomains = allowedDomains;
+    cachedAllowlistHash = integrity.actualHash;
     return allowedDomains;
 }
+let cachedAllowedDomains = null;
+let cachedAllowlistHash = null;
 /**
  * Suspicious URL patterns that should always be rejected
  */
@@ -188,6 +205,18 @@ function validateAllProviderUrls(providers) {
                 validation: validateEmailProviderUrl(provider.loginUrl)
             });
         }
+        else {
+            // Providers without URLs are counted but marked as invalid for audit purposes
+            // (they don't affect security level, but are tracked for completeness)
+            results.push({
+                provider: provider.companyProvider || 'Unknown',
+                url: provider.loginUrl || '',
+                validation: {
+                    isValid: false,
+                    reason: provider.loginUrl === '' ? 'Empty URL provided' : 'No URL provided'
+                }
+            });
+        }
     }
     return results;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikkelscheike/email-provider-links",
-  "version": "4.0.11",
+  "version": "5.1.0",
   "description": "TypeScript library for email provider detection with 130 providers (218 domains), concurrent DNS resolution, optimized performance, 94.65% test coverage, and enterprise security for login and password reset flows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,7 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
+    "test:live-dns": "RUN_LIVE_DNS=1 jest",
     "prepublishOnly": "npm run verify-hashes && npm run build",
     "dev": "tsx src/index.ts",
     "sync-versions": "node scripts/sync-versions.js",
@@ -74,7 +75,7 @@
     "@semantic-release/npm": "^13.1.2",
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.3",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "jest": "^30.2.0",
     "semantic-release": "^25.0.2",

package/dist/loader.d.ts

@@ -1,45 +0,0 @@
-/**
- * Provider Data Loader
- *
- * Handles loading email provider data with performance optimizations.
- */
-import { EmailProvider } from './api';
-/**
- * Loading statistics for performance monitoring
- */
-interface LoadingStats {
-    fileSize: number;
-    loadTime: number;
-    providerCount: number;
-    domainCount: number;
-}
-/**
- * Build optimized domain-to-provider lookup map
- */
-export declare function buildDomainMap(providers: EmailProvider[]): Map<string, EmailProvider>;
-/**
- * Clear all caches (useful for testing or hot reloading)
- */
-export declare function clearCache(): void;
-/**
- * Get loading statistics from the last load operation
- */
-export declare function getLoadingStats(): LoadingStats | null;
-/**
- * Load all providers with optimized domain map for production
- */
-export declare function loadProviders(): {
-    providers: EmailProvider[];
-    domainMap: Map<string, EmailProvider>;
-    stats: LoadingStats;
-};
-/**
- * Load providers with debug information
- */
-export declare function loadProvidersDebug(): {
-    providers: EmailProvider[];
-    domainMap: Map<string, EmailProvider>;
-    stats: LoadingStats;
-};
-export {};
-//# sourceMappingURL=loader.d.ts.map

package/dist/loader.js

@@ -1,163 +0,0 @@
-"use strict";
-/**
- * Provider Data Loader
- *
- * Handles loading email provider data with performance optimizations.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDomainMap = buildDomainMap;
-exports.clearCache = clearCache;
-exports.getLoadingStats = getLoadingStats;
-exports.loadProviders = loadProviders;
-exports.loadProvidersDebug = loadProvidersDebug;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const schema_1 = require("./schema");
-/**
- * Internal cached data
- */
-let cachedProviders = null;
-let cachedDomainMap = null;
-let loadingStats = null;
-/**
- * Default loader configuration
- */
-const DEFAULT_CONFIG = {
-    debug: false
-};
-/**
- * Convert compressed provider to EmailProvider format
- */
-function convertProviderToEmailProvider(compressedProvider) {
-    if (!compressedProvider.type) {
-        console.warn(`Missing type for provider ${compressedProvider.id}`);
-    }
-    const provider = {
-        companyProvider: compressedProvider.companyProvider,
-        loginUrl: compressedProvider.loginUrl || null,
-        domains: compressedProvider.domains || [],
-        type: compressedProvider.type,
-        alias: compressedProvider.alias
-    };
-    // Include DNS detection patterns for business email services and proxy services
-    const needsCustomDomainDetection = compressedProvider.type === 'custom_provider' ||
-        compressedProvider.type === 'proxy_service';
-    if (needsCustomDomainDetection && (compressedProvider.mx?.length || compressedProvider.txt?.length)) {
-        provider.customDomainDetection = {};
-        if (compressedProvider.mx?.length) {
-            provider.customDomainDetection.mxPatterns = compressedProvider.mx;
-        }
-        if (compressedProvider.txt?.length) {
-            // Decompress TXT patterns
-            provider.customDomainDetection.txtPatterns = compressedProvider.txt.map(schema_1.decompressTxtPattern);
-        }
-    }
-    return provider;
-}
-/**
- * Internal provider data loader with configuration
- */
-function loadProvidersInternal(config = {}) {
-    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-    const startTime = Date.now();
-    // Return cached data if available
-    if (cachedProviders && !mergedConfig.debug) {
-        return {
-            providers: cachedProviders,
-            stats: loadingStats
-        };
-    }
-    try {
-        // Determine file path
-        const basePath = (0, path_1.join)(__dirname, '..', 'providers');
-        const dataPath = mergedConfig.path || (0, path_1.join)(basePath, 'emailproviders.json');
-        if (mergedConfig.debug)
-            console.log('🔄 Loading provider data...');
-        const content = (0, fs_1.readFileSync)(dataPath, 'utf8');
-        const data = JSON.parse(content);
-        // Validate format
-        if (!data.version || !data.providers || !Array.isArray(data.providers)) {
-            throw new Error('Invalid provider data format');
-        }
-        const providers = data.providers.map(convertProviderToEmailProvider);
-        const fileSize = content.length;
-        if (mergedConfig.debug) {
-            console.log(`✅ Loaded ${providers.length} providers`);
-            console.log(`📊 File size: ${(fileSize / 1024).toFixed(1)} KB`);
-        }
-        const loadTime = Date.now() - startTime;
-        const domainCount = providers.reduce((sum, p) => sum + p.domains.length, 0);
-        // Cache the results
-        cachedProviders = providers;
-        loadingStats = {
-            fileSize,
-            loadTime,
-            providerCount: providers.length,
-            domainCount
-        };
-        if (mergedConfig.debug) {
-            console.log(`⚡ Loading completed in ${loadTime}ms`);
-            console.log(`📊 Stats: ${providers.length} providers, ${domainCount} domains`);
-        }
-        if (process.env.NODE_ENV === 'development') {
-            const memoryUsageInMB = process.memoryUsage().heapUsed / 1024 / 1024;
-            console.log(`🚀 Current memory usage: ${memoryUsageInMB.toFixed(2)} MB`);
-        }
-        return {
-            providers,
-            stats: loadingStats
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        throw new Error(`Failed to load provider data: ${errorMessage}`);
-    }
-}
-/**
- * Build optimized domain-to-provider lookup map
- */
-function buildDomainMap(providers) {
-    if (cachedDomainMap) {
-        return cachedDomainMap;
-    }
-    const domainMap = new Map();
-    for (const provider of providers) {
-        for (const domain of provider.domains) {
-            domainMap.set(domain.toLowerCase(), provider);
-        }
-    }
-    cachedDomainMap = domainMap;
-    return domainMap;
-}
-/**
- * Clear all caches (useful for testing or hot reloading)
- */
-function clearCache() {
-    cachedProviders = null;
-    cachedDomainMap = null;
-    loadingStats = null;
-}
-/**
- * Get loading statistics from the last load operation
- */
-function getLoadingStats() {
-    return loadingStats;
-}
-/**
- * Load all providers with optimized domain map for production
- */
-function loadProviders() {
-    const { providers, stats } = loadProvidersInternal({ debug: false });
-    const domainMap = buildDomainMap(providers);
-    return { providers, domainMap, stats };
-}
-/**
- * Load providers with debug information
- */
-function loadProvidersDebug() {
-    clearCache(); // Always reload in debug mode
-    const { providers, stats } = loadProvidersInternal({ debug: true });
-    const domainMap = buildDomainMap(providers);
-    return { providers, domainMap, stats };
-}
-//# sourceMappingURL=loader.js.map