@nocobase/plugin-workflow-mailer 2.2.19 → 2.2.21

package/dist/node_modules/nodemailer/dist/cjs/mailer/index.d.ts

@@ -0,0 +1,237 @@
+import { EventEmitter } from 'node:events';
+import * as shared from '../shared/index.js';
+import DKIM, { type DKIMOptions } from '../dkim/index.js';
+import MailMessage, { type MailDefaults, type SendMailOptions } from './mail-message.js';
+import net from 'node:net';
+import type { ConnectionOptions } from 'node:tls';
+import type { MailComposerAlternative, MailComposerAttachment, MailComposerIcalEvent, MailComposerListHeaderEntry, MailComposerListHeaders, MailComposerTextEncoding } from '../mail-composer/index.js';
+import type { Callback, NodemailerError, ResultCallback } from '../errors.js';
+import type { ParsedUrl } from '../shared/url.js';
+import type { MimeNodeAddress, MimeNodeEnvelope, MimeNodeEnvelopeInput, MimeNodeHeaders, MimeNodeOptions } from '../mime-node/index.js';
+import type { XOAuth2ProvisionCallback } from '../xoauth2/index.js';
+export type { SendMailOptions, MailDefaults, MailMessageData, MailMessageDataCallback, MailMessageContentCallback, MailMessageListHeader, MailMessageListHeaderValue } from './mail-message.js';
+export type { default as MailMessage } from './mail-message.js';
+/**
+ * The base shape of the object a transport hands back for a sent message. Every bundled
+ * transport sets the envelope and the Message-ID, the rest depends on the transport.
+ *
+ * The index signature keeps a transport specific field readable through this type, the way
+ * the `any` typed result of @types/nodemailer was, and it is also what a result type has
+ * to inherit to stay assignable to it, so the result type of a transport outside this
+ * package has to extend this interface rather than restate it
+ */
+export interface SentMessageInfo {
+    /** The envelope the message was sent with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID of the sent message */
+    messageId: string;
+    /** Recipient addresses the transport accepted */
+    accepted?: string[] | undefined;
+    /** Recipient addresses the transport rejected */
+    rejected?: string[] | undefined;
+    /** Recipient addresses left pending, LMTP reports these */
+    pending?: string[] | undefined;
+    /** Last response from the server */
+    response?: string | undefined;
+    /** The generated message, for the transports that hand it back instead of sending it */
+    message?: any;
+    /** Transport specific fields */
+    [key: string]: any;
+}
+/**
+ * Callback for sendMail, receives the transport result once the transport has taken the
+ * message
+ */
+export type SendMailCallback<T = SentMessageInfo> = (err: NodemailerError | null, info: T) => void;
+/**
+ * Callback for verify(), success is true once the transport accepted the configuration.
+ * Declared with a required success value, the way @types/nodemailer declared it, the
+ * error path hands over the error alone
+ */
+export type VerifyCallback = Callback<true>;
+/**
+ * Callback a plugin calls once it is done, an error aborts the send
+ */
+export type PluginCallback = (err?: NodemailerError | null) => void;
+/**
+ * A plugin registered with use(): receives the message and a callback to call once done
+ */
+export type PluginFunction<T = SentMessageInfo> = (mail: MailMessage<T>, callback: PluginCallback) => void;
+/**
+ * Connection options a getSocket handler receives: the options of the transport asking for
+ * the socket, with the host and port to connect to
+ */
+export interface GetSocketOptions {
+    host?: string | undefined;
+    port?: number | undefined;
+    [key: string]: any;
+}
+/**
+ * The result of a getSocket handler, the socket to use for the connection. The object is
+ * merged into the connection options, so it may carry any of those as well
+ */
+export interface SocketOptions {
+    /** An established socket, the proxied connection */
+    connection?: net.Socket | undefined;
+    [key: string]: any;
+}
+/**
+ * Receives the socket options from a getSocket handler, false when a new socket should be
+ * opened, or the error that prevented the connection
+ */
+export type GetSocketCallback = (err: Error | null, socketOptions?: SocketOptions | false) => void;
+/**
+ * A socket handler. Mail sets one on the transport as getSocket when a proxy is configured,
+ * the SMTP transports call it to get a proxied socket instead of connecting directly
+ */
+export type GetSocketHandler = (options: GetSocketOptions, callback: GetSocketCallback) => void;
+/**
+ * A custom proxy handler, registered with set('proxy_handler_' + protocol, handler) for the
+ * protocol of the proxy url
+ */
+export type ProxyHandler = (proxy: ParsedUrl, options: GetSocketOptions, callback: GetSocketCallback) => void;
+/**
+ * Well known keys of the meta store, see set() and get(): the OAuth2 token provisioning
+ * callback the SMTP transports use, the socks module for socks proxies, and a custom proxy
+ * handler per proxy protocol
+ */
+export interface MailMeta {
+    /** Called by the SMTP transports when a new OAuth2 access token is needed */
+    oauth2_provision_cb: XOAuth2ProvisionCallback;
+    /** The socks module, v1 or v2, used to connect through a socks proxy */
+    proxy_socks_module: any;
+    [key: `proxy_handler_${string}`]: ProxyHandler;
+    [key: string]: any;
+}
+/**
+ * A transport as consumed by Mail: any object with a name, a version and a send method
+ * works, the rest is optional. Mail forwards its close, isIdle and verify calls to the
+ * methods of the same name as they are, so their arguments are up to the transport.
+ *
+ * D is the options type of the transport, the second type parameter @types/nodemailer
+ * declared on Transport, Transporter and Mail
+ */
+export interface Transport<T = SentMessageInfo, D extends TransportOptions = TransportOptions> {
+    /** Transport name, used for logging */
+    name: string;
+    /** Transport version, used for logging */
+    version: string;
+    /** Hands a message to the transport, the callback receives the transport result */
+    send(mail: MailMessage<T>, callback: ResultCallback<T>): void;
+    /** Checks the configuration, the SMTP transports connect and authenticate for it */
+    verify?(...args: any[]): any;
+    /** Closes the transport */
+    close?(...args: any[]): any;
+    /** Tells whether the transport can take a message right away */
+    isIdle?(...args: any[]): any;
+    /** Registers an event listener, the transport may emit 'log', 'error', 'idle' and 'clear' */
+    on?(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** The Mail object the transport belongs to, set by Mail */
+    mailer?: Mail<T, D> | undefined;
+    /** Socket handler for a proxied connection, set by Mail when a proxy is configured */
+    getSocket?: GetSocketHandler | undefined;
+}
+/**
+ * Transport configuration as read by Mail itself. The transport reads its own options from
+ * the same object, see the transport for those
+ */
+export interface TransportOptions {
+    /** Bunyan compatible logger, true for the default console logger, false or unset for no logging */
+    logger?: shared.ExternalLogger | boolean | undefined;
+    /** Component name for the log lines, defaults to 'mail' */
+    component?: string | undefined;
+    /** DKIM signing options, every message is signed with these unless it carries its own */
+    dkim?: DKIMOptions | undefined;
+    /** Proxy url. http(s) proxies work as is, socks proxies need the socks module set with set('proxy_socks_module', socks) */
+    proxy?: string | undefined;
+    /** TLS options, rejectUnauthorized applies to an https proxy as well */
+    tls?: ConnectionOptions | undefined;
+    /** Reject content that points to a file path, forced onto every message */
+    disableFileAccess?: boolean | undefined;
+    /** Reject content that points to a URL, forced onto every message */
+    disableUrlAccess?: boolean | undefined;
+    /** Method to normalize header keys for custom caseing, forced onto every message */
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
+    /** Recipients allowed on one message, forced onto every message, 0 disables the limit, defaults to 100000 */
+    maxRecipients?: number | undefined;
+    /** Convert data: images in the html into embedded attachments */
+    attachDataUrls?: boolean | undefined;
+}
+/**
+ * The transporter object createTransport returns, a Mail instance wrapping a transport. D
+ * is the options type of the transport, it types the options field of the transporter
+ */
+export type Transporter<T = SentMessageInfo, D extends TransportOptions = TransportOptions> = Mail<T, D>;
+/**
+ * Creates an object for exposing the Mail API
+ *
+ * @constructor
+ * @param transporter Transport object instance to pass the mails to
+ */
+declare class Mail<out T = SentMessageInfo, out D extends TransportOptions = TransportOptions> extends EventEmitter {
+    options: D;
+    /** Message defaults given to createTransport, kept public because the DefinitelyTyped typings declared it */
+    _defaults: MailDefaults;
+    meta: Map<string, any>;
+    dkim: DKIM | false;
+    transporter: Transport<T, D>;
+    logger: shared.Logger;
+    /** Closes the transport, the pooled SMTP transport closes its connections */
+    close: () => void;
+    /** Tells whether the transport can take a message right away */
+    isIdle: () => boolean;
+    /** Checks the configuration, the SMTP transports connect and authenticate for it */
+    verify: {
+        (callback: VerifyCallback): void;
+        (): Promise<true>;
+    };
+    /** Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send */
+    getSocket?: GetSocketHandler | false | undefined;
+    constructor(transporter: Transport<T, D>, options?: D, defaults?: MailDefaults);
+    use(step: string, plugin: PluginFunction<T>): this;
+    /**
+     * Sends an email using the preselected transport object
+     *
+     * @param data E-data description
+     * @returns Promise that resolves with the result of the send
+     */
+    sendMail(data: SendMailOptions): Promise<T>;
+    /**
+     * Sends an email using the preselected transport object
+     *
+     * @param data E-data description
+     * @param callback Callback to run once the sending succeeded or failed
+     */
+    sendMail(data: SendMailOptions, callback: SendMailCallback<T>): void;
+    getVersionString(): string;
+    /**
+     * Sets up proxy handler for a Nodemailer object
+     *
+     * @param proxyUrl Proxy configuration url
+     */
+    setupProxy(proxyUrl: string): void;
+    set<K extends keyof MailMeta & string>(key: K, value: MailMeta[K]): Map<string, any>;
+    get<K extends keyof MailMeta & string>(key: K): MailMeta[K] | undefined;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `Mail.Options` style references keep working
+ */
+type MailPluginFunction<T> = PluginFunction<T>;
+declare namespace Mail {
+    type Options = SendMailOptions;
+    type Address = MimeNodeAddress;
+    type Attachment = MailComposerAttachment;
+    type AttachmentLike = MailComposerAlternative;
+    type AmpAttachment = MailComposerAlternative;
+    type IcalAttachment = MailComposerIcalEvent;
+    type Headers = MimeNodeHeaders;
+    type ListHeader = MailComposerListHeaderEntry;
+    type ListHeaders = MailComposerListHeaders;
+    type Envelope = MimeNodeEnvelopeInput;
+    type Connection = SocketOptions;
+    type TextEncoding = MailComposerTextEncoding;
+    type PluginFunction<T = SentMessageInfo> = MailPluginFunction<T>;
+}
+/** The same aliases as module level exports, for `import * as Mail` and `import Mail = require()` */
+export type { SendMailOptions as Options, MimeNodeAddress as Address, MailComposerAttachment as Attachment, MailComposerAlternative as AttachmentLike, MailComposerAlternative as AmpAttachment, MailComposerIcalEvent as IcalAttachment, MimeNodeHeaders as Headers, MailComposerListHeaderEntry as ListHeader, MailComposerListHeaders as ListHeaders, MimeNodeEnvelopeInput as Envelope, SocketOptions as Connection, MailComposerTextEncoding as TextEncoding };
+export default Mail;

package/dist/node_modules/nodemailer/dist/cjs/mailer/index.js

@@ -0,0 +1,415 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const shared = __importStar(require("../shared/index.js"));
+const mimeTypes = __importStar(require("../mime-funcs/mime-types.js"));
+const index_js_1 = __importDefault(require("../mail-composer/index.js"));
+const index_js_2 = __importDefault(require("../dkim/index.js"));
+const http_proxy_client_js_1 = __importDefault(require("../smtp-connection/http-proxy-client.js"));
+const errors = __importStar(require("../errors.js"));
+const node_util_1 = __importDefault(require("node:util"));
+const urllib = __importStar(require("../shared/url.js"));
+const packageData = __importStar(require("../package-info.js"));
+const mail_message_js_1 = __importDefault(require("./mail-message.js"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_dns_1 = __importDefault(require("node:dns"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+/**
+ * Recipients allowed on one message unless the caller sets its own maxRecipients. A backstop
+ * against a runaway or hostile recipient list rather than a delivery policy: RFC 5321 only
+ * asks a server to accept 100, so a real send is bounded far below this.
+ */
+const DEFAULT_MAX_RECIPIENTS = 100000;
+/**
+ * Creates an object for exposing the Mail API
+ *
+ * @constructor
+ * @param transporter Transport object instance to pass the mails to
+ */
+class Mail extends node_events_1.EventEmitter {
+    constructor(transporter, options, defaults) {
+        super();
+        this.options = options || {};
+        this._defaults = defaults || {};
+        this._defaultPlugins = {
+            compile: [(...args) => this._convertDataImages(...args)],
+            stream: []
+        };
+        this._userPlugins = {
+            compile: [],
+            stream: []
+        };
+        this.meta = new Map();
+        this.dkim = this.options.dkim ? new index_js_2.default(this.options.dkim) : false;
+        this.transporter = transporter;
+        this.transporter.mailer = this;
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'mail'
+        });
+        this.logger.debug({
+            tnx: 'create'
+        }, 'Creating transport: %s', this.getVersionString());
+        // setup emit handlers for the transporter
+        if (typeof this.transporter.on === 'function') {
+            // deprecated log interface
+            this.transporter.on('log', log => {
+                this.logger.debug({
+                    tnx: 'transport'
+                }, '%s: %s', log.type, log.message);
+            });
+            // transporter errors
+            this.transporter.on('error', err => {
+                this.logger.error({
+                    err,
+                    tnx: 'transport'
+                }, 'Transport Error: %s', err.message);
+                this.emit('error', err);
+            });
+            // indicates if the sender has became idle
+            this.transporter.on('idle', (...args) => {
+                this.emit('idle', ...args);
+            });
+            // indicates if the sender has became idle and all connections are terminated
+            this.transporter.on('clear', (...args) => {
+                this.emit('clear', ...args);
+            });
+        }
+        /**
+         * Optional methods passed to the underlying transport object
+         */
+        ['close', 'isIdle', 'verify'].forEach(method => {
+            this[method] = (...args) => {
+                if (typeof this.transporter[method] === 'function') {
+                    if (method === 'verify' && typeof this.getSocket === 'function') {
+                        this.transporter.getSocket = this.getSocket;
+                        this.getSocket = false;
+                    }
+                    return this.transporter[method](...args);
+                }
+                this.logger.warn({
+                    tnx: 'transport',
+                    methodName: method
+                }, 'Non existing method %s called for transport', method);
+                return false;
+            };
+        });
+        // setup proxy handling
+        if (this.options.proxy && typeof this.options.proxy === 'string') {
+            this.setupProxy(this.options.proxy);
+        }
+    }
+    use(step, plugin) {
+        step = (step || '').toString();
+        if (!this._userPlugins.hasOwnProperty(step)) {
+            this._userPlugins[step] = [plugin];
+        }
+        else {
+            this._userPlugins[step].push(plugin);
+        }
+        return this;
+    }
+    sendMail(data, callback = null) {
+        let promise;
+        if (!callback) {
+            promise = new Promise((resolve, reject) => {
+                callback = shared.callbackPromise(resolve, reject);
+            });
+        }
+        const done = callback;
+        if (typeof this.getSocket === 'function') {
+            this.transporter.getSocket = this.getSocket;
+            this.getSocket = false;
+        }
+        const mail = new mail_message_js_1.default(this, data);
+        this.logger.debug({
+            tnx: 'transport',
+            name: this.transporter.name,
+            version: this.transporter.version,
+            action: 'send'
+        }, 'Sending mail using %s/%s', this.transporter.name, this.transporter.version);
+        this._processPlugins('compile', mail, err => {
+            if (err) {
+                this.logger.error({
+                    err,
+                    tnx: 'plugin',
+                    action: 'compile'
+                }, 'PluginCompile Error: %s', err.message);
+                return done(err);
+            }
+            let recipientCount;
+            try {
+                mail.message = new index_js_1.default(mail.data).compile();
+                mail.setMailerHeader();
+                mail.setPriorityHeaders();
+                mail.setListHeaders();
+                recipientCount = mail.message.getEnvelope().to.length;
+            }
+            catch (err) {
+                // message data can throw while it is compiled, the error belongs to the callback
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Compile Error: %s', err.message);
+                return done(err);
+            }
+            const maxRecipients = mail.data.maxRecipients === undefined ? DEFAULT_MAX_RECIPIENTS : mail.data.maxRecipients;
+            if (maxRecipients && recipientCount > maxRecipients) {
+                const err = new Error(`Message has ${recipientCount} recipients, which is over the ${maxRecipients} allowed by maxRecipients`);
+                err.code = errors.EMAXRECIPIENTS;
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Send Error: %s', err.message);
+                return done(err);
+            }
+            this._processPlugins('stream', mail, err => {
+                if (err) {
+                    this.logger.error({
+                        err,
+                        tnx: 'plugin',
+                        action: 'stream'
+                    }, 'PluginStream Error: %s', err.message);
+                    return done(err);
+                }
+                if (mail.data.dkim || this.dkim) {
+                    mail.message.processFunc(input => {
+                        const dkim = mail.data.dkim ? new index_js_2.default(mail.data.dkim) : this.dkim;
+                        this.logger.debug({
+                            tnx: 'DKIM',
+                            messageId: mail.message.messageId(),
+                            dkimDomains: dkim.keys.map(key => key.keySelector + '.' + key.domainName).join(', ')
+                        }, 'Signing outgoing message with %s keys', dkim.keys.length);
+                        return dkim.sign(input, mail.data._dkim);
+                    });
+                }
+                this.transporter.send(mail, (...args) => {
+                    if (args[0]) {
+                        this.logger.error({
+                            err: args[0],
+                            tnx: 'transport',
+                            action: 'send'
+                        }, 'Send Error: %s', args[0].message);
+                    }
+                    done(...args);
+                });
+            });
+        });
+        return promise;
+    }
+    getVersionString() {
+        return node_util_1.default.format('%s (%s; +%s; %s/%s)', packageData.name, packageData.version, packageData.homepage, this.transporter.name, this.transporter.version);
+    }
+    /** @internal */
+    _processPlugins(step, mail, callback) {
+        step = (step || '').toString();
+        if (!this._userPlugins.hasOwnProperty(step)) {
+            return callback();
+        }
+        const userPlugins = this._userPlugins[step] || [];
+        const defaultPlugins = this._defaultPlugins[step] || [];
+        if (userPlugins.length) {
+            this.logger.debug({
+                tnx: 'transaction',
+                pluginCount: userPlugins.length,
+                step
+            }, 'Using %s plugins for %s', userPlugins.length, step);
+        }
+        if (userPlugins.length + defaultPlugins.length === 0) {
+            return callback();
+        }
+        let pos = 0;
+        let block = 'default';
+        const processPlugins = () => {
+            let curplugins = block === 'default' ? defaultPlugins : userPlugins;
+            if (pos >= curplugins.length) {
+                if (block === 'default' && userPlugins.length) {
+                    block = 'user';
+                    pos = 0;
+                    curplugins = userPlugins;
+                }
+                else {
+                    return callback();
+                }
+            }
+            const plugin = curplugins[pos++];
+            plugin(mail, err => {
+                if (err) {
+                    return callback(err);
+                }
+                processPlugins();
+            });
+        };
+        processPlugins();
+    }
+    /**
+     * Sets up proxy handler for a Nodemailer object
+     *
+     * @param proxyUrl Proxy configuration url
+     */
+    setupProxy(proxyUrl) {
+        const proxy = urllib.parse(proxyUrl);
+        // setup socket handler for the mailer object
+        this.getSocket = (options, callback) => {
+            const protocol = proxy.protocol.replace(/:$/, '').toLowerCase();
+            if (this.meta.has('proxy_handler_' + protocol)) {
+                return this.meta.get('proxy_handler_' + protocol)(proxy, options, callback);
+            }
+            switch (protocol) {
+                // Connect using a HTTP CONNECT method
+                case 'http':
+                case 'https':
+                    (0, http_proxy_client_js_1.default)(proxy.href, options.port, options.host, this.options.tls || {}, (err, socket) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        return callback(null, {
+                            connection: socket
+                        });
+                    });
+                    return;
+                case 'socks':
+                case 'socks5':
+                case 'socks4':
+                case 'socks4a': {
+                    if (!this.meta.has('proxy_socks_module')) {
+                        let err = new Error('Socks module not loaded');
+                        err.code = errors.EPROXY;
+                        return callback(err);
+                    }
+                    const connect = (ipaddress) => {
+                        const proxyV2 = !!this.meta.get('proxy_socks_module').SocksClient;
+                        const socksClient = proxyV2 ? this.meta.get('proxy_socks_module').SocksClient : this.meta.get('proxy_socks_module');
+                        const proxyType = Number(proxy.protocol.replace(/\D/g, '')) || 5;
+                        const connectionOpts = {
+                            proxy: {
+                                ipaddress,
+                                port: Number(proxy.port),
+                                type: proxyType
+                            },
+                            [proxyV2 ? 'destination' : 'target']: {
+                                host: options.host,
+                                port: options.port
+                            },
+                            command: 'connect'
+                        };
+                        if (proxy.username || proxy.password) {
+                            const username = proxy.username || '';
+                            const password = proxy.password || '';
+                            if (proxyV2) {
+                                connectionOpts.proxy.userId = username;
+                                connectionOpts.proxy.password = password;
+                            }
+                            else if (proxyType === 4) {
+                                connectionOpts.userid = username;
+                            }
+                            else {
+                                connectionOpts.authentication = {
+                                    username,
+                                    password
+                                };
+                            }
+                        }
+                        socksClient.createConnection(connectionOpts, (err, info) => {
+                            if (err) {
+                                return callback(err);
+                            }
+                            return callback(null, {
+                                connection: info.socket || info
+                            });
+                        });
+                    };
+                    if (node_net_1.default.isIP(proxy.hostname)) {
+                        return connect(proxy.hostname);
+                    }
+                    return node_dns_1.default.resolve(proxy.hostname, (err, address) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        connect(Array.isArray(address) ? address[0] : address);
+                    });
+                }
+            }
+            let err = new Error('Unknown proxy configuration');
+            err.code = errors.EPROXY;
+            callback(err);
+        };
+    }
+    /** @internal */
+    _convertDataImages(mail, callback) {
+        if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) {
+            return callback();
+        }
+        mail.resolveContent(mail.data, 'html', { disableFileAccess: mail.data.disableFileAccess, disableUrlAccess: mail.data.disableUrlAccess }, (err, html) => {
+            if (err) {
+                return callback(err);
+            }
+            let cidCounter = 0;
+            html = (html || '')
+                .toString()
+                .replace(/(<img\b[^<>]{0,1024} src\s{0,20}=[\s"']{0,20})(data:([^;]+);[^"'>\s]+)/gi, (match, prefix, dataUri, mimeType) => {
+                const cid = node_crypto_1.default.randomBytes(10).toString('hex') + '@localhost';
+                if (!mail.data.attachments) {
+                    mail.data.attachments = [];
+                }
+                if (!Array.isArray(mail.data.attachments)) {
+                    mail.data.attachments = [].concat(mail.data.attachments || []);
+                }
+                mail.data.attachments.push({
+                    path: dataUri,
+                    cid,
+                    filename: 'image-' + ++cidCounter + '.' + mimeTypes.detectExtension(mimeType)
+                });
+                return prefix + 'cid:' + cid;
+            });
+            mail.data.html = html;
+            callback();
+        });
+    }
+    set(key, value) {
+        return this.meta.set(key, value);
+    }
+    get(key) {
+        return this.meta.get(key);
+    }
+}
+exports.default = Mail;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });