@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/routing/index.d.ts

@@ -0,0 +1,5 @@
+export * from './classes.email.router.js';
+export * from './classes.unified.email.server.js';
+export * from './classes.dns.manager.js';
+export * from './interfaces.js';
+export * from './classes.domain.registry.js';

package/dist_ts/ts/mail/routing/index.js

@@ -0,0 +1,7 @@
+// Email routing components
+export * from './classes.email.router.js';
+export * from './classes.unified.email.server.js';
+export * from './classes.dns.manager.js';
+export * from './interfaces.js';
+export * from './classes.domain.registry.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9tYWlsL3JvdXRpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMkJBQTJCO0FBQzNCLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw4QkFBOEIsQ0FBQyJ9

package/dist_ts/ts/mail/routing/interfaces.d.ts

@@ -0,0 +1,187 @@
+import type { Email } from '../core/classes.email.js';
+import type { IExtendedSmtpSession } from './classes.unified.email.server.js';
+/**
+ * Route configuration for email routing
+ */
+export interface IEmailRoute {
+    /** Route identifier */
+    name: string;
+    /** Order of evaluation (higher priority evaluated first, default: 0) */
+    priority?: number;
+    /** Conditions to match */
+    match: IEmailMatch;
+    /** Action to take when matched */
+    action: IEmailAction;
+}
+/**
+ * Match criteria for email routing
+ */
+export interface IEmailMatch {
+    /** Email patterns to match recipients: "*@example.com", "admin@*" */
+    recipients?: string | string[];
+    /** Email patterns to match senders */
+    senders?: string | string[];
+    /** IP addresses or CIDR ranges to match */
+    clientIp?: string | string[];
+    /** Require authentication status */
+    authenticated?: boolean;
+    /** Headers to match */
+    headers?: Record<string, string | RegExp>;
+    /** Message size range */
+    sizeRange?: {
+        min?: number;
+        max?: number;
+    };
+    /** Subject line patterns */
+    subject?: string | RegExp;
+    /** Has attachments */
+    hasAttachments?: boolean;
+}
+/**
+ * Action to take when route matches
+ */
+export interface IEmailAction {
+    /** Type of action to perform */
+    type: 'forward' | 'deliver' | 'reject' | 'process';
+    /** Forward action configuration */
+    forward?: {
+        /** Target host to forward to */
+        host: string;
+        /** Target port (default: 25) */
+        port?: number;
+        /** Authentication credentials */
+        auth?: {
+            user: string;
+            pass: string;
+        };
+        /** Preserve original headers */
+        preserveHeaders?: boolean;
+        /** Additional headers to add */
+        addHeaders?: Record<string, string>;
+    };
+    /** Reject action configuration */
+    reject?: {
+        /** SMTP response code */
+        code: number;
+        /** SMTP response message */
+        message: string;
+    };
+    /** Process action configuration */
+    process?: {
+        /** Enable content scanning */
+        scan?: boolean;
+        /** Enable DKIM signing */
+        dkim?: boolean;
+        /** Delivery queue priority */
+        queue?: 'normal' | 'priority' | 'bulk';
+    };
+    /** Options for various action types */
+    options?: {
+        /** MTA specific options */
+        mtaOptions?: {
+            domain?: string;
+            allowLocalDelivery?: boolean;
+            localDeliveryPath?: string;
+            dkimSign?: boolean;
+            dkimOptions?: {
+                domainName: string;
+                keySelector: string;
+                privateKey?: string;
+            };
+            smtpBanner?: string;
+            maxConnections?: number;
+            connTimeout?: number;
+            spoolDir?: string;
+        };
+        /** Content scanning configuration */
+        contentScanning?: boolean;
+        scanners?: Array<{
+            type: 'spam' | 'virus' | 'attachment';
+            threshold?: number;
+            action: 'tag' | 'reject';
+            blockedExtensions?: string[];
+        }>;
+        /** Email transformations */
+        transformations?: Array<{
+            type: string;
+            header?: string;
+            value?: string;
+            domains?: string[];
+            append?: boolean;
+            [key: string]: any;
+        }>;
+    };
+    /** Delivery options (applies to forward/process/deliver) */
+    delivery?: {
+        /** Rate limit (messages per minute) */
+        rateLimit?: number;
+        /** Number of retry attempts */
+        retries?: number;
+    };
+}
+/**
+ * Context for route evaluation
+ */
+export interface IEmailContext {
+    /** The email being routed */
+    email: Email;
+    /** The SMTP session */
+    session: IExtendedSmtpSession;
+}
+/**
+ * Email domain configuration
+ */
+export interface IEmailDomainConfig {
+    /** Domain name */
+    domain: string;
+    /** DNS handling mode */
+    dnsMode: 'forward' | 'internal-dns' | 'external-dns';
+    /** DNS configuration based on mode */
+    dns?: {
+        /** For 'forward' mode */
+        forward?: {
+            /** Skip DNS validation (default: false) */
+            skipDnsValidation?: boolean;
+            /** Target server's expected domain */
+            targetDomain?: string;
+        };
+        /** For 'internal-dns' mode */
+        internal?: {
+            /** TTL for DNS records in seconds (default: 3600) */
+            ttl?: number;
+            /** MX record priority (default: 10) */
+            mxPriority?: number;
+        };
+        /** For 'external-dns' mode */
+        external?: {
+            /** Custom DNS servers (default: system DNS) */
+            servers?: string[];
+            /** Which records to validate (default: ['MX', 'SPF', 'DKIM', 'DMARC']) */
+            requiredRecords?: ('MX' | 'SPF' | 'DKIM' | 'DMARC')[];
+        };
+    };
+    /** Per-domain DKIM settings (DKIM always enabled) */
+    dkim?: {
+        /** DKIM selector (default: 'default') */
+        selector?: string;
+        /** Key size in bits (default: 2048) */
+        keySize?: number;
+        /** Automatically rotate keys (default: false) */
+        rotateKeys?: boolean;
+        /** Days between key rotations (default: 90) */
+        rotationInterval?: number;
+    };
+    /** Per-domain rate limits */
+    rateLimits?: {
+        outbound?: {
+            messagesPerMinute?: number;
+            messagesPerHour?: number;
+            messagesPerDay?: number;
+        };
+        inbound?: {
+            messagesPerMinute?: number;
+            connectionsPerIp?: number;
+            recipientsPerMessage?: number;
+        };
+    };
+}

package/dist_ts/ts/mail/routing/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL21haWwvcm91dGluZy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/ts/mail/security/classes.dkimcreator.d.ts

@@ -0,0 +1,68 @@
+import * as plugins from '../../plugins.js';
+import { Email } from '../core/classes.email.js';
+export interface IKeyPaths {
+    privateKeyPath: string;
+    publicKeyPath: string;
+}
+export interface IDkimKeyMetadata {
+    domain: string;
+    selector: string;
+    createdAt: number;
+    rotatedAt?: number;
+    previousSelector?: string;
+    keySize: number;
+}
+export declare class DKIMCreator {
+    private keysDir;
+    private storageManager?;
+    constructor(keysDir?: string, storageManager?: any);
+    getKeyPathsForDomain(domainArg: string): Promise<IKeyPaths>;
+    handleDKIMKeysForDomain(domainArg: string): Promise<void>;
+    handleDKIMKeysForEmail(email: Email): Promise<void>;
+    readDKIMKeys(domainArg: string): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    createDKIMKeys(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    storeDKIMKeys(privateKey: string, publicKey: string, privateKeyPath: string, publicKeyPath: string): Promise<void>;
+    createAndStoreDKIMKeys(domain: string): Promise<void>;
+    getDNSRecordForDomain(domainArg: string): Promise<plugins.tsclass.network.IDnsRecord>;
+    /**
+     * Get DKIM key metadata for a domain
+     */
+    private getKeyMetadata;
+    /**
+     * Save DKIM key metadata
+     */
+    private saveKeyMetadata;
+    /**
+     * Check if DKIM keys need rotation
+     */
+    needsRotation(domain: string, selector?: string, rotationIntervalDays?: number): Promise<boolean>;
+    /**
+     * Rotate DKIM keys for a domain
+     */
+    rotateDkimKeys(domain: string, currentSelector?: string, keySize?: number): Promise<string>;
+    /**
+     * Get key paths for a specific selector
+     */
+    getKeyPathsForSelector(domain: string, selector: string): Promise<IKeyPaths>;
+    /**
+     * Read DKIM keys for a specific selector
+     */
+    readDKIMKeysForSelector(domain: string, selector: string): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    /**
+     * Get DNS record for a specific selector
+     */
+    getDNSRecordForSelector(domain: string, selector: string): Promise<plugins.tsclass.network.IDnsRecord>;
+    /**
+     * Clean up old DKIM keys after grace period
+     */
+    cleanupOldKeys(domain: string, gracePeriodDays?: number): Promise<void>;
+}

package/dist_ts/ts/mail/security/classes.dkimcreator.js

@@ -0,0 +1,346 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { Email } from '../core/classes.email.js';
+// MtaService reference removed
+const readFile = plugins.util.promisify(plugins.fs.readFile);
+const writeFile = plugins.util.promisify(plugins.fs.writeFile);
+const generateKeyPair = plugins.util.promisify(plugins.crypto.generateKeyPair);
+export class DKIMCreator {
+    constructor(keysDir = paths.keysDir, storageManager) {
+        this.keysDir = keysDir;
+        this.storageManager = storageManager;
+    }
+    async getKeyPathsForDomain(domainArg) {
+        return {
+            privateKeyPath: plugins.path.join(this.keysDir, `${domainArg}-private.pem`),
+            publicKeyPath: plugins.path.join(this.keysDir, `${domainArg}-public.pem`),
+        };
+    }
+    // Check if a DKIM key is present and creates one and stores it to disk otherwise
+    async handleDKIMKeysForDomain(domainArg) {
+        try {
+            await this.readDKIMKeys(domainArg);
+        }
+        catch (error) {
+            console.log(`No DKIM keys found for ${domainArg}. Generating...`);
+            await this.createAndStoreDKIMKeys(domainArg);
+            const dnsValue = await this.getDNSRecordForDomain(domainArg);
+            plugins.smartfile.fs.ensureDirSync(paths.dnsRecordsDir);
+            plugins.smartfile.memory.toFsSync(JSON.stringify(dnsValue, null, 2), plugins.path.join(paths.dnsRecordsDir, `${domainArg}.dkimrecord.json`));
+        }
+    }
+    async handleDKIMKeysForEmail(email) {
+        const domain = email.from.split('@')[1];
+        await this.handleDKIMKeysForDomain(domain);
+    }
+    // Read DKIM keys - always use storage manager, migrate from filesystem if needed
+    async readDKIMKeys(domainArg) {
+        // Try to read from storage manager first
+        if (this.storageManager) {
+            try {
+                const [privateKey, publicKey] = await Promise.all([
+                    this.storageManager.get(`/email/dkim/${domainArg}/private.key`),
+                    this.storageManager.get(`/email/dkim/${domainArg}/public.key`)
+                ]);
+                if (privateKey && publicKey) {
+                    return { privateKey, publicKey };
+                }
+            }
+            catch (error) {
+                // Fall through to migration check
+            }
+            // Check if keys exist in filesystem and migrate them to storage manager
+            const keyPaths = await this.getKeyPathsForDomain(domainArg);
+            try {
+                const [privateKeyBuffer, publicKeyBuffer] = await Promise.all([
+                    readFile(keyPaths.privateKeyPath),
+                    readFile(keyPaths.publicKeyPath),
+                ]);
+                // Convert the buffers to strings
+                const privateKey = privateKeyBuffer.toString();
+                const publicKey = publicKeyBuffer.toString();
+                // Migrate to storage manager
+                console.log(`Migrating DKIM keys for ${domainArg} from filesystem to StorageManager`);
+                await Promise.all([
+                    this.storageManager.set(`/email/dkim/${domainArg}/private.key`, privateKey),
+                    this.storageManager.set(`/email/dkim/${domainArg}/public.key`, publicKey)
+                ]);
+                return { privateKey, publicKey };
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    // Keys don't exist anywhere
+                    throw new Error(`DKIM keys not found for domain ${domainArg}`);
+                }
+                throw error;
+            }
+        }
+        else {
+            // No storage manager, use filesystem directly
+            const keyPaths = await this.getKeyPathsForDomain(domainArg);
+            const [privateKeyBuffer, publicKeyBuffer] = await Promise.all([
+                readFile(keyPaths.privateKeyPath),
+                readFile(keyPaths.publicKeyPath),
+            ]);
+            const privateKey = privateKeyBuffer.toString();
+            const publicKey = publicKeyBuffer.toString();
+            return { privateKey, publicKey };
+        }
+    }
+    // Create a DKIM key pair - changed to public for API access
+    async createDKIMKeys() {
+        const { privateKey, publicKey } = await generateKeyPair('rsa', {
+            modulusLength: 2048,
+            publicKeyEncoding: { type: 'spki', format: 'pem' },
+            privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
+        });
+        return { privateKey, publicKey };
+    }
+    // Store a DKIM key pair - uses storage manager if available, else disk
+    async storeDKIMKeys(privateKey, publicKey, privateKeyPath, publicKeyPath) {
+        // Store in storage manager if available
+        if (this.storageManager) {
+            // Extract domain from path (e.g., /path/to/keys/example.com-private.pem -> example.com)
+            const match = privateKeyPath.match(/\/([^\/]+)-private\.pem$/);
+            if (match) {
+                const domain = match[1];
+                await Promise.all([
+                    this.storageManager.set(`/email/dkim/${domain}/private.key`, privateKey),
+                    this.storageManager.set(`/email/dkim/${domain}/public.key`, publicKey)
+                ]);
+            }
+        }
+        // Also store to filesystem for backward compatibility
+        await Promise.all([writeFile(privateKeyPath, privateKey), writeFile(publicKeyPath, publicKey)]);
+    }
+    // Create a DKIM key pair and store it to disk - changed to public for API access
+    async createAndStoreDKIMKeys(domain) {
+        const { privateKey, publicKey } = await this.createDKIMKeys();
+        const keyPaths = await this.getKeyPathsForDomain(domain);
+        await this.storeDKIMKeys(privateKey, publicKey, keyPaths.privateKeyPath, keyPaths.publicKeyPath);
+        console.log(`DKIM keys for ${domain} created and stored.`);
+    }
+    // Changed to public for API access
+    async getDNSRecordForDomain(domainArg) {
+        await this.handleDKIMKeysForDomain(domainArg);
+        const keys = await this.readDKIMKeys(domainArg);
+        // Remove the PEM header and footer and newlines
+        const pemHeader = '-----BEGIN PUBLIC KEY-----';
+        const pemFooter = '-----END PUBLIC KEY-----';
+        const keyContents = keys.publicKey
+            .replace(pemHeader, '')
+            .replace(pemFooter, '')
+            .replace(/\n/g, '');
+        // Now generate the DKIM DNS TXT record
+        const dnsRecordValue = `v=DKIM1; h=sha256; k=rsa; p=${keyContents}`;
+        return {
+            name: `mta._domainkey.${domainArg}`,
+            type: 'TXT',
+            dnsSecEnabled: null,
+            value: dnsRecordValue,
+        };
+    }
+    /**
+     * Get DKIM key metadata for a domain
+     */
+    async getKeyMetadata(domain, selector = 'default') {
+        if (!this.storageManager) {
+            return null;
+        }
+        const metadataKey = `/email/dkim/${domain}/${selector}/metadata`;
+        const metadataStr = await this.storageManager.get(metadataKey);
+        if (!metadataStr) {
+            return null;
+        }
+        return JSON.parse(metadataStr);
+    }
+    /**
+     * Save DKIM key metadata
+     */
+    async saveKeyMetadata(metadata) {
+        if (!this.storageManager) {
+            return;
+        }
+        const metadataKey = `/email/dkim/${metadata.domain}/${metadata.selector}/metadata`;
+        await this.storageManager.set(metadataKey, JSON.stringify(metadata));
+    }
+    /**
+     * Check if DKIM keys need rotation
+     */
+    async needsRotation(domain, selector = 'default', rotationIntervalDays = 90) {
+        const metadata = await this.getKeyMetadata(domain, selector);
+        if (!metadata) {
+            // No metadata means old keys, should rotate
+            return true;
+        }
+        const now = Date.now();
+        const keyAgeMs = now - metadata.createdAt;
+        const keyAgeDays = keyAgeMs / (1000 * 60 * 60 * 24);
+        return keyAgeDays >= rotationIntervalDays;
+    }
+    /**
+     * Rotate DKIM keys for a domain
+     */
+    async rotateDkimKeys(domain, currentSelector = 'default', keySize = 2048) {
+        console.log(`Rotating DKIM keys for ${domain}...`);
+        // Generate new selector based on date
+        const now = new Date();
+        const newSelector = `key${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}`;
+        // Create new keys with custom key size
+        const { privateKey, publicKey } = await generateKeyPair('rsa', {
+            modulusLength: keySize,
+            publicKeyEncoding: { type: 'spki', format: 'pem' },
+            privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
+        });
+        // Store new keys with new selector
+        const newKeyPaths = await this.getKeyPathsForSelector(domain, newSelector);
+        // Store in storage manager if available
+        if (this.storageManager) {
+            await Promise.all([
+                this.storageManager.set(`/email/dkim/${domain}/${newSelector}/private.key`, privateKey),
+                this.storageManager.set(`/email/dkim/${domain}/${newSelector}/public.key`, publicKey)
+            ]);
+        }
+        // Also store to filesystem
+        await this.storeDKIMKeys(privateKey, publicKey, newKeyPaths.privateKeyPath, newKeyPaths.publicKeyPath);
+        // Save metadata for new keys
+        const metadata = {
+            domain,
+            selector: newSelector,
+            createdAt: Date.now(),
+            previousSelector: currentSelector,
+            keySize
+        };
+        await this.saveKeyMetadata(metadata);
+        // Update metadata for old keys
+        const oldMetadata = await this.getKeyMetadata(domain, currentSelector);
+        if (oldMetadata) {
+            oldMetadata.rotatedAt = Date.now();
+            await this.saveKeyMetadata(oldMetadata);
+        }
+        console.log(`DKIM keys rotated for ${domain}. New selector: ${newSelector}`);
+        return newSelector;
+    }
+    /**
+     * Get key paths for a specific selector
+     */
+    async getKeyPathsForSelector(domain, selector) {
+        return {
+            privateKeyPath: plugins.path.join(this.keysDir, `${domain}-${selector}-private.pem`),
+            publicKeyPath: plugins.path.join(this.keysDir, `${domain}-${selector}-public.pem`),
+        };
+    }
+    /**
+     * Read DKIM keys for a specific selector
+     */
+    async readDKIMKeysForSelector(domain, selector) {
+        // Try to read from storage manager first
+        if (this.storageManager) {
+            try {
+                const [privateKey, publicKey] = await Promise.all([
+                    this.storageManager.get(`/email/dkim/${domain}/${selector}/private.key`),
+                    this.storageManager.get(`/email/dkim/${domain}/${selector}/public.key`)
+                ]);
+                if (privateKey && publicKey) {
+                    return { privateKey, publicKey };
+                }
+            }
+            catch (error) {
+                // Fall through to migration check
+            }
+            // Check if keys exist in filesystem and migrate them to storage manager
+            const keyPaths = await this.getKeyPathsForSelector(domain, selector);
+            try {
+                const [privateKeyBuffer, publicKeyBuffer] = await Promise.all([
+                    readFile(keyPaths.privateKeyPath),
+                    readFile(keyPaths.publicKeyPath),
+                ]);
+                const privateKey = privateKeyBuffer.toString();
+                const publicKey = publicKeyBuffer.toString();
+                // Migrate to storage manager
+                console.log(`Migrating DKIM keys for ${domain}/${selector} from filesystem to StorageManager`);
+                await Promise.all([
+                    this.storageManager.set(`/email/dkim/${domain}/${selector}/private.key`, privateKey),
+                    this.storageManager.set(`/email/dkim/${domain}/${selector}/public.key`, publicKey)
+                ]);
+                return { privateKey, publicKey };
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    throw new Error(`DKIM keys not found for domain ${domain} with selector ${selector}`);
+                }
+                throw error;
+            }
+        }
+        else {
+            // No storage manager, use filesystem directly
+            const keyPaths = await this.getKeyPathsForSelector(domain, selector);
+            const [privateKeyBuffer, publicKeyBuffer] = await Promise.all([
+                readFile(keyPaths.privateKeyPath),
+                readFile(keyPaths.publicKeyPath),
+            ]);
+            const privateKey = privateKeyBuffer.toString();
+            const publicKey = publicKeyBuffer.toString();
+            return { privateKey, publicKey };
+        }
+    }
+    /**
+     * Get DNS record for a specific selector
+     */
+    async getDNSRecordForSelector(domain, selector) {
+        const keys = await this.readDKIMKeysForSelector(domain, selector);
+        // Remove the PEM header and footer and newlines
+        const pemHeader = '-----BEGIN PUBLIC KEY-----';
+        const pemFooter = '-----END PUBLIC KEY-----';
+        const keyContents = keys.publicKey
+            .replace(pemHeader, '')
+            .replace(pemFooter, '')
+            .replace(/\n/g, '');
+        // Generate the DKIM DNS TXT record
+        const dnsRecordValue = `v=DKIM1; h=sha256; k=rsa; p=${keyContents}`;
+        return {
+            name: `${selector}._domainkey.${domain}`,
+            type: 'TXT',
+            dnsSecEnabled: null,
+            value: dnsRecordValue,
+        };
+    }
+    /**
+     * Clean up old DKIM keys after grace period
+     */
+    async cleanupOldKeys(domain, gracePeriodDays = 30) {
+        if (!this.storageManager) {
+            return;
+        }
+        // List all selectors for the domain
+        const metadataKeys = await this.storageManager.list(`/email/dkim/${domain}/`);
+        for (const key of metadataKeys) {
+            if (key.endsWith('/metadata')) {
+                const metadataStr = await this.storageManager.get(key);
+                if (metadataStr) {
+                    const metadata = JSON.parse(metadataStr);
+                    // Check if key is rotated and past grace period
+                    if (metadata.rotatedAt) {
+                        const gracePeriodMs = gracePeriodDays * 24 * 60 * 60 * 1000;
+                        const now = Date.now();
+                        if (now - metadata.rotatedAt > gracePeriodMs) {
+                            console.log(`Cleaning up old DKIM keys for ${domain} selector ${metadata.selector}`);
+                            // Delete key files
+                            const keyPaths = await this.getKeyPathsForSelector(domain, metadata.selector);
+                            try {
+                                await plugins.fs.promises.unlink(keyPaths.privateKeyPath);
+                                await plugins.fs.promises.unlink(keyPaths.publicKeyPath);
+                            }
+                            catch (error) {
+                                console.warn(`Failed to delete old key files: ${error.message}`);
+                            }
+                            // Delete metadata
+                            await this.storageManager.delete(key);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dkimcreator.js","sourceRoot":"","sources":["../../../../ts/mail/security/classes.dkimcreator.ts"],"names":[],"mappings":"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"}