@flun/mailer 2.1.4

package/lib/mail-composer.js

@@ -0,0 +1,316 @@
+import { MimeNode } from './mime-node/index.js';
+import { regexs, resetRegex, parseDataURI } from './shared.js';
+import { detectMimeType, detectExtension } from './mime-funcs/index.js';
+/**
+ * 邮件编译器类,用于从邮件选项组合MimeNode实例;
+ * 负责处理邮件的多部分结构（纯文本、HTML、附件等）
+ * >查看定义:@see {@link MailComposer}
+ * @class MailComposer
+ */
+class MailComposer {
+    constructor(mail = {}) { this.mail = mail, this.message = false; }
+
+    /**
+     * 编译邮件内容，生成MimeNode实例
+     * 根据邮件内容类型（纯文本、HTML、附件等）构建相应的MIME结构
+     * @returns {MimeNode} 编译后的MimeNode实例
+     */
+    compile() {
+        const aTives = this._alternatives = this.getAlternatives();  // 获取所有替代内容（纯文本、HTML、日历事件等）
+        // 从替代内容中提取HTML节点
+        this._htmlNode = aTives.filter(alternative => regexs.HTML_TYPE.test(alternative.contentType)).pop();
+        // 获取附件，并根据是否存在HTML内容区分相关附件
+        const { attached, related } = this._attachments = this.getAttachments(!!this._htmlNode);
+
+        // 确定需要使用的MIME类型结构
+        this._useRelated = !!(this._htmlNode && related.length);                          // 是否需要相关部分（HTML + 内联图片）
+        this._useAlternative = aTives.length > 1;                                         // 是否需要替代部分（纯文本 + HTML）
+        this._useMixed = attached.length > 1 || (aTives.length && attached.length === 1); // 是否需要混合部分（内容 + 附件）
+
+        // 根据内容类型构建相应的MIME结构
+        const { raw, newline, headers, envelope } = this.mail;
+        if (raw) this.message = new MimeNode('message/rfc822', { newline }).setRaw(raw); // 如果有raw字段，则直接使用raw字段
+        else if (this._useMixed) this.message = this.#createMixed();                     // 混合类型：内容 + 多个附件
+        else if (this._useAlternative) this.message = this.#createAlternative();         // 替代类型：纯文本 + HTML
+        else if (this._useRelated) this.message = this.#createRelated();                 // 相关类型：HTML + 内联资源
+        else this.message = this.#createContentNode(false, [aTives, attached].flatMap(arr => arr || [])
+            .find(Boolean) || { contentType: 'text/plain', content: '' });               // 简单类型：单一内容
+
+        if (headers) this.message.addHeader(headers);  // 添加自定义邮件头
+        // 设置标准邮件头
+        const rHR = resetRegex(regexs.HYPHEN_REPLACE);
+        ['from', 'sender', 'to', 'cc', 'bcc', 'reply-to', 'in-reply-to', 'references', 'subject', 'message-id', 'date']
+            .forEach(header => {
+                const key = header.replace(rHR, (_, c) => c.toUpperCase());
+                if (this.mail[key]) this.message.setHeader(header, this.mail[key]);
+            });
+
+        // 设置邮件信封和消息ID
+        if (envelope) this.message.setEnvelope(envelope);
+        this.message.messageId();
+        return this.message;
+    }
+
+    /**
+     * 获取邮件附件列表
+     * 处理普通附件和相关附件（如内联图片）
+     * @param {boolean} findRelated - 是否查找相关附件（用于HTML内联）
+     * @returns {Object} 包含attached和related附件的对象
+     */
+    getAttachments(findRelated = false) {
+        const { attachments = [], icalEvent } = this.mail;
+        let eventObject;
+
+        // 处理日历事件附件
+        if (icalEvent) {
+            const iEvent = typeof icalEvent === 'object' && (icalEvent.content || icalEvent.path || icalEvent.href || icalEvent.raw)
+                ? { ...icalEvent } : { content: icalEvent };
+
+            eventObject = {
+                ...iEvent, contentType: 'application/ics', filename: iEvent.filename || 'invite.ics',
+                headers: { ...iEvent.headers, 'Content-Disposition': 'attachment', 'Content-Transfer-Encoding': 'base64' }
+            };
+        }
+
+        // 处理所有附件
+        const pAttachments = attachments.map((attachment, i) => {
+            const pAtt = this.#prepareAttachmentObject(attachment), // 预处理附件
+                { filename, path, href, cid, raw, encoding, headers, contentType: cType, content = '', httpHeaders } = pAtt,
+                source = path || href || 'bin', contentType = cType || detectMimeType(filename || source),
+                isImage = regexs.IMAGE_TYPE.test(contentType), isMessageNode = regexs.MESSAGE_TYPE.test(contentType),
+                contentDisposition = pAtt.contentDisposition || (isMessageNode || (isImage && cid) ? 'inline' : 'attachment'),
+                contentTransferEncoding = 'contentTransferEncoding' in pAtt ? pAtt.contentTransferEncoding
+                    : isMessageNode ? '7bit' : 'base64',
+                // 构建附件数据
+                data = {
+                    contentType, contentDisposition, contentTransferEncoding, ...(filename && { filename }),
+                    ...(cid && { cid }), ...(raw && { raw }), ...(encoding && { encoding }), ...(headers && { headers })
+                };
+
+            // 处理文件名生成
+            if (!filename && !isMessageNode && filename !== false) {
+                const baseName = source.split('/').pop().split('?').shift();
+                data.filename = baseName && !baseName.includes('.')
+                    ? `${baseName}.${detectExtension(contentType)}` : baseName || `attachment-${i + 1}`;
+            }
+
+            // 设置内容源（优先级：raw > path > href > content）
+            if (!raw) data.content = path ? { path } : href ? { href, httpHeaders } : content;
+            return data;
+        }), eventArray = eventObject ? [eventObject] : [];
+        return findRelated ?
+            { attached: pAttachments.filter(a => !a.cid).concat(eventArray), related: pAttachments.filter(a => a.cid) }
+            : { attached: pAttachments.concat(eventArray), related: [] };
+    }
+
+    /**
+     * 获取邮件的替代内容（纯文本、HTML、日历事件等）
+     * 用于构建多部分替代结构
+     * @returns {Array} 替代内容数组
+     */
+    getAlternatives() {
+        let text_, html_, watchHtml_, amp_, eventObject;
+        const { text, html, watchHtml, amp, icalEvent, alternatives } = this.mail,
+            // 处理替代内容对象
+            processAlt = (letValue, v, defaultContentType) => {
+                letValue = (typeof v === 'object' && (v.content || v.path || v.href || v.raw)) ? v : { content: v };
+                letValue.contentType = defaultContentType;
+                return letValue;
+            };
+
+        // 处理纯文本内容,Apple Watch HTML内容,AMP HTML内容
+        if (text) text_ = processAlt(text_, text, 'text/plain; charset=utf-8');
+        if (watchHtml) watchHtml_ = processAlt(watchHtml_, watchHtml, 'text/watch-html; charset=utf-8');
+        if (amp) amp_ = processAlt(amp_, amp, 'text/x-amp-html; charset=utf-8');
+
+        // 处理日历事件
+        if (icalEvent) {
+            const iEvent = processAlt(iEvent, icalEvent, null);
+            eventObject = {
+                ...iEvent, filename: false,
+                contentType: `text/calendar; charset=utf-8; method=${(iEvent.method || 'PUBLISH').toString().trim().toUpperCase()}`,
+                headers: iEvent.headers || {},
+                ...(iEvent.content && typeof iEvent.content === 'object' && { content: { ...iEvent.content, _resolve: true } })
+            };
+        }
+
+        // 处理HTML内容
+        if (html) html_ = processAlt(html_, html, 'text/html; charset=utf-8');
+
+        // 将所有替代内容合并到数组中
+        const gAlternatives = Array.prototype.concat.call([], text_, html_, watchHtml_, amp_, eventObject, alternatives)
+            .filter(Boolean).map(originalAlternative => {
+                const oAtive = this.#prepareAttachmentObject(originalAlternative), // 预处理附件
+                    { contentType, filename, path, href, raw, content = '', contentTransferEncoding, encoding, headers } = oAtive,
+                    data = ({
+                        contentType: contentType || detectMimeType(filename || path || href || 'txt'), contentTransferEncoding,
+                        ...(raw && { raw }), ...(filename && { filename }), ...(encoding && { encoding }), ...(headers && { headers })
+                    });
+
+                if (!raw) data.content = path ? { path } : href ? { href } : content;// 设置内容源(优先级:raw>path>href>content)
+                return data;
+            });
+
+        return gAlternatives;
+    }
+
+    /**
+     * 预处理附件对象（处理dataURL和标准化路径,将HTTP / HTTPS路径转换为href属性）
+     * @param {Object} obj - 要处理的附件对象
+     * @returns {Object} 处理后的对象
+     */
+    #prepareAttachmentObject(obj) {
+        // 处理dataURL格式的内容和标准化路径
+        const prepared = regexs.DATA_URL.test(obj.path || obj.href) ? { ...obj, ...this.#processDataUrl(obj) } : { ...obj },
+            { path } = prepared;
+        if (regexs.HTTP_URL.test(path)) prepared.href = path, prepared.path = undefined;
+        return prepared;
+    }
+
+    /**
+     * 创建MIME节点（根节点或子节点）
+     * @param {MimeNode|null} parentNode - 父节点，如果为null则创建根节点
+     * @param {string} mimeType - MIME类型
+     * @returns {MimeNode} 创建的节点
+     */
+    #createMimeNode(parentNode, mimeType) {
+        return !parentNode ? this.#createRootMimeNode(mimeType) : parentNode.createChild(mimeType, this.#getChildNodeOptions());
+    }
+
+    /**
+     * 创建混合类型的MIME节点（内容 + 附件）
+     * @param {MimeNode} parentNode - 父节点
+     * @returns {MimeNode} 创建的混合节点
+     */
+    #createMixed(parentNode) {
+        const node = this.#createMimeNode(parentNode, 'multipart/mixed');
+        // 根据内容类型添加子节点
+        if (this._useAlternative) this.#createAlternative(node);
+        else if (this._useRelated) this.#createRelated(node);
+
+        // 添加所有替代内容和附件
+        [...(this._useAlternative ? [] : this._alternatives || []), ...(this._attachments.attached || [])]
+            .filter(element => !this._useRelated || element !== this._htmlNode)
+            .forEach(element => this.#createContentNode(node, element));
+
+        return node;
+    }
+
+    /**
+     * 创建替代类型的MIME节点（纯文本 + HTML）
+     * @param {MimeNode} parentNode - 父节点
+     * @returns {MimeNode} 创建的替代节点
+     */
+    #createAlternative(parentNode) {
+        const node = this.#createMimeNode(parentNode, 'multipart/alternative');
+        // 添加所有替代内容
+        this._alternatives.forEach(ative => {
+            this._useRelated && this._htmlNode === ative ? this.#createRelated(node) : this.#createContentNode(node, ative);
+        });
+
+        return node;
+    }
+
+    /**
+     * 创建相关类型的MIME节点（HTML + 内联资源）
+     * @param {MimeNode} parentNode - 父节点
+     * @returns {MimeNode} 创建的相关节点
+     */
+    #createRelated(parentNode) {
+        const node = this.#createMimeNode(parentNode, 'multipart/related; type="text/html"');
+        // 添加HTML内容和相关附件
+        this.#createContentNode(node, this._htmlNode);
+        this._attachments.related.forEach(alternative => this.#createContentNode(node, alternative));
+        return node;
+    }
+
+    /**
+     * 创建内容节点
+     * @param {MimeNode} parentNode - 父节点
+     * @param {Object} element - 内容元素
+     * @returns {MimeNode} 创建的内容节点
+     */
+    #createContentNode(parentNode, element = {}) {
+        const { encoding = 'utf8', filename, headers, cid, contentTransferEncoding, contentType, contentDisposition,
+            content = '', raw } = element, rEF = resetRegex(regexs.ENCODING_FORMAT),
+            eEncoding = encoding.toString().toLowerCase().replace(rEF, ''),
+            { baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline,
+                encoding: mEncoding } = this.mail
+
+        // 创建节点（根节点或子节点）
+        const node = !parentNode ? new MimeNode(contentType, {
+            filename, baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline
+        }) : parentNode.createChild(contentType, {
+            filename, textEncoding, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline
+        });
+
+        // 设置节点头信息
+        if (headers) node.addHeader(headers);
+        const rCC = resetRegex(regexs.CID_CLEAN), CTE = 'Content-Transfer-Encoding';
+        if (cid) node.setHeader('Content-Id', `<${cid.replace(rCC, '')}>`);
+        if (contentTransferEncoding) node.setHeader(CTE, contentTransferEncoding);
+        else if (mEncoding && regexs.TEXT_TYPE.test(contentType)) node.setHeader(CTE, mEncoding);
+
+        // 设置内容处置方式
+        if (!regexs.TEXT_TYPE.test(contentType) || contentDisposition || filename) node.setHeader('Content-Disposition',
+            contentDisposition || (cid && regexs.IMAGE_TYPE.test(contentType) ? 'inline' : 'attachment'));
+
+        // 处理内容编码
+        let newContent = content;
+        if (typeof newContent === 'string' && !['utf8', 'usascii', 'ascii'].includes(eEncoding))
+            newContent = Buffer.from(newContent, eEncoding);
+
+        raw ? node.setRaw(raw) : node.setContent(newContent);  // 设置节点内容
+        return node;
+    }
+
+    /**
+     * 处理DataURL格式的内容
+     * 将DataURL转换为二进制内容
+     * @param {Object} element - 包含DataURL的元素
+     * @returns {Object} 处理后的元素
+     */
+    #processDataUrl(element) {
+        const { path, href, contentType = 'application/octet-stream' } = element, dataUrl = path || href;
+        if (!dataUrl || typeof dataUrl !== 'string' || !dataUrl.startsWith('data:')) return element;
+        // 对过大的DataURL进行限制
+        if (dataUrl.length > 100000) return { ...element, path: false, href: false, content: Buffer.alloc(0), contentType };
+
+        let parsedDataUri;
+        try {
+            parsedDataUri = parseDataURI(dataUrl);
+        } catch (err) {
+            return element;
+        }
+
+        // 替换DataURL为解析后的内容
+        element.content = parsedDataUri.data, element.contentType = parsedDataUri.contentType || contentType;
+        if ('path' in element) element.path = false;
+        if ('href' in element) element.href = false;
+
+        return element;
+    }
+
+    /**
+     * 创建根MIME节点
+     * @param {string} contentType - 内容类型
+     * @returns {MimeNode} 创建的根节点
+     */
+    #createRootMimeNode(contentType) {
+        const { baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline } = this.mail;
+        return new MimeNode(contentType, {
+            baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline
+        });
+    }
+
+    /**
+     * 获取子节点配置选项
+     * @returns {Object} 子节点配置选项
+     */
+    #getChildNodeOptions() {
+        const { disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline } = this.mail;
+        return { disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline };
+    }
+}
+
+export { MailComposer };

package/lib/mailer/index.js

@@ -0,0 +1,301 @@
+import { EventEmitter } from 'events';
+import { randomBytes } from 'crypto';
+import { MailMessage } from './mail-message.js';
+import { MailComposer } from '../mail-composer.js';
+import { DKIM } from '../dkim/index.js';
+import { httpProxyClient } from '../http-proxy-client.js';
+import { detectExtension } from '../mime-funcs/index.js';
+import { PK, format, isIP, dnsResolve, regexs, resetRegex, getLogger, callbackPromise, newURL } from '../shared.js';
+
+/**
+ * 创建 Mail API 对象
+ * >查看定义:@see {@link Mailer}
+ * @constructor
+ * @param {Object} transporter 用于传递邮件传输器对象的实例
+ */
+class Mailer extends 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();                               // 元数据存储
+        const { dkim, proxy, component = 'mailer' } = this.options;
+        this.dkim = dkim ? new DKIM(dkim) : false;           // DKIM配置（域名密钥识别邮件）
+        this.transporter = transporter, this.transporter.mailer = this;                 // 设置传输器并建立反向引用
+        this.logger = getLogger(this.options, { component }); // 初始化日志记录器
+        this.logger.debug({ tnx: 'create' }, '创建传输器: %s', this.getVersionString()); // 记录创建日志
+
+        // 设置传输器的事件处理器
+        if (typeof this.transporter.on === 'function') {
+            this.transporter
+                // 日志,错误,进入空闲状态,所有连接已终止各事件监听
+                .on('log', log => this.logger.debug({ tnx: 'transport' }, '%s: %s', log.type, log.message))
+                .on('error', err => {
+                    this.logger.error({ err, tnx: 'transport' }, '传输器错误: %s', err.message), this.emit('error', err);
+                })
+                .on('idle', (...args) => this.emit('idle', ...args)).on('clear', (...args) => this.emit('clear', ...args));
+        }
+
+        // 为底层传输器对象添加可选方法
+        ['close', 'isIdle', 'verify'].forEach(method => {
+            this[method] = (...args) => {
+                if (typeof this.transporter[method] === 'function') {
+                    // 特殊处理verify方法，设置getSocket
+                    if (method === 'verify' && typeof this.getSocket === 'function') this.#setupTransporterSocket();
+                    return this.transporter[method](...args);
+                } else {
+                    this.logger.warn({ tnx: 'transport', methodName: method }, '传输器不支持的方法 %s', method);
+                    return false;
+                }
+            };
+        });
+
+        if (proxy && typeof proxy === 'string') this.setupProxy(proxy); // 如果有代理，则设置代理
+    }
+
+    /**
+     * 设置传输器的socket获取方法
+     * 将当前实例的getSocket方法赋值给传输器,并重置当前实例的getSocket
+     */
+    #setupTransporterSocket() {
+        this.transporter.getSocket = this.getSocket, this.getSocket = false;
+    }
+
+    /**
+     * 使用插件
+     * @param {string} step 插件阶段（'compile'或'stream'）
+     * @param {Function} plugin 插件函数
+     */
+    use(step = '', plugin) {
+        const stepKey = step.toString(), sPlugins = this._userPlugins;
+        // 如果没有这个步骤,则创建一个数组,否则添加到数组中
+        sPlugins[stepKey] = sPlugins[stepKey] ?? [], sPlugins[stepKey].push(plugin);
+        return this;
+    }
+
+    /**
+     * 使用预选的传输器对象发送邮件
+     *
+     * @param {Object} data 邮件数据描述
+     * @param {Function?} callback 发送成功或失败后运行的回调函数
+     */
+    sendMail(data, callback = null) {
+        // 如果没有提供回调，则创建Promise
+        const promise = !callback ? new Promise((resolve, reject) => callback = callbackPromise(resolve, reject)) : null,
+            mail = new MailMessage(this, data);                                   // 创建邮件消息对象
+        if (typeof this.getSocket === 'function') this.#setupTransporterSocket(); // 设置传输器的getSocket方法
+
+        // 记录发送日志
+        const { name, version } = this.transporter;
+        this.logger.debug({ tnx: 'transport', name, version, action: 'send' }, '使用 %s/%s 发送邮件', name, version);
+
+        const isCallbackErr = (err, action, context, tnx = 'plugin') => {
+            if (err) {
+                this.logger.error({ err, tnx, action }, context, err.message);
+                return callback(err);
+            }
+        };
+
+        // 处理编译阶段插件
+        this.#processPlugins('compile', mail, err => {
+            isCallbackErr(err, 'compile', '插件编译错误: %s'), mail.message = new MailComposer(mail.data).compile();
+            mail.setMailerHeader(), mail.setPriorityHeaders(), mail.setListHeaders(); // 设置各种邮件头
+
+            // 处理流阶段插件
+            this.#processPlugins('stream', mail, err => {
+                isCallbackErr(err, 'stream', '插件流错误: %s');
+                const mailDKIM = mail.data.dkim;
+                // DKIM签名处理
+                if (mailDKIM || this.dkim) {
+                    mail.message.processFunc(input => {
+                        // 使用邮件数据中的DKIM配置或全局DKIM配置
+                        const dkim = mailDKIM ? new DKIM(mailDKIM) : this.dkim;
+                        this.logger.debug(
+                            {
+                                tnx: 'DKIM', messageId: mail.message.messageId(),
+                                dkimDomains: dkim.keys.map(key => `${key.keySelector}.${key.domainName}`).join(', ')
+                            }, '使用 %s 个密钥签署外发邮件', dkim.keys.length
+                        );
+                        return dkim.sign(input);
+                    });
+                }
+
+                // 使用传输器发送邮件
+                this.transporter.send(mail, (err, ...args) => {
+                    isCallbackErr(err, 'send', '发送错误: %s', 'transport'), callback(null, ...args);
+                });
+            });
+        });
+
+        return promise;
+    }
+
+    /**
+     * 获取版本字符串
+     */
+    getVersionString() {
+        const { name, version } = this.transporter;
+        return format('%s (%s; +%s; %s/%s)', PK.name, PK.version, PK.homepage, name, version);
+    }
+
+    /**
+     * 处理插件
+     * @param {string} step 处理阶段
+     * @param {Object} mail 邮件对象
+     * @param {Function} callback 回调函数
+     */
+    #processPlugins(step = '', mail, callback) {
+        step = step.toString();
+        if (!this._userPlugins.hasOwnProperty(step)) return callback(); // 如果没有这个步骤，则直接返回
+
+        const userPlugins = this._userPlugins[step] || [], defaultPlugins = this._defaultPlugins[step] || [],
+            count = userPlugins.length;
+        // 记录插件使用情况(如果没有插件，则直接返回)
+        if (count) this.logger.debug({ tnx: 'transaction', pluginCount: count, step }, '在 %s 阶段使用 %s 个插件', step, count);
+        if (count + defaultPlugins.length === 0) return callback();
+
+        // 递归处理插件
+        let pos = 0, block = 'default';
+        const processPlugins = () => {
+            let curPlugins = block === 'default' ? defaultPlugins : userPlugins;
+            // 如果当前位置超过了当前插件列表的长度，则切换到下一个插件列表
+            if (pos >= curPlugins.length) {
+                if (block === 'default' && count) block = 'user', pos = 0, curPlugins = userPlugins;
+                else return callback();
+            }
+            let plugin = curPlugins[pos++];
+            plugin(mail, err => {
+                if (err) return callback(err); // 如果插件返回错误，则直接返回
+                processPlugins();
+            });
+        };
+
+        processPlugins();
+    }
+
+    /**
+     * 为Nodemailer对象设置代理处理器
+     *
+     * @param {String} proxyUrl 代理配置URL
+     */
+    setupProxy(proxyUrl) {
+        const proxy = newURL(proxyUrl);
+        if (!proxy) throw new Error(`无效的代理URL: ${proxyUrl}`);
+
+        // 为mailer对象设置socket处理器
+        this.getSocket = (options, callback) => {
+            const { protocol: protocol_, href, port: pPort, auth, hostname } = proxy,
+                protocol = (protocol_.endsWith(':') ? protocol_.slice(0, -1) : protocol_).toLowerCase(),
+                proxyHandlerKey = `proxy_handler_${protocol}`;
+            // 检查是否有自定义代理处理器
+            if (this.meta.has(proxyHandlerKey)) return this.meta.get(proxyHandlerKey)(proxy, options, callback);
+            const { port, host } = options;
+            // 根据协议类型处理不同代理
+            switch (protocol) {
+                // 使用HTTP CONNECT方法连接
+                case 'http':
+                case 'https':
+                    httpProxyClient(href, port, host, (err, socket) => {
+                        return err ? callback(err) : callback(null, { connection: socket });
+                    });
+                    return;
+                case 'socks':
+                case 'socks5':
+                case 'socks4':
+                case 'socks4a': {
+                    const moduleName = 'proxy_socks_module'
+                    // 检查是否已加载Socks模块
+                    if (!this.meta.has(moduleName)) return callback(new Error('未加载Socks模块'));
+
+                    const connect = ipaddress => {
+                        const proxyV2 = !!this.meta.get(moduleName).SocksClient,
+                            socksClient = proxyV2 ? this.meta.get(moduleName).SocksClient : this.meta.get(moduleName),
+                            rND = resetRegex(regexs.NON_DIGIT), type = Number(protocol_.replace(rND, '')) || 5,
+                            connectionOpts = {
+                                proxy: { ipaddress, port: Number(pPort), type },
+                                [proxyV2 ? 'destination' : 'target']: { host, port }, command: 'connect'
+                            };
+
+                        // 处理代理认证
+                        if (auth) {
+                            const username = decodeURIComponent(auth.split(':').shift()),
+                                password = decodeURIComponent(auth.split(':').pop());
+                            // 如果使用Socks5代理v2，则使用userId和password字段，否则使用authentication字段
+                            if (proxyV2) connectionOpts.proxy.userId = username, connectionOpts.proxy.password = password;
+                            else if (type === 4) connectionOpts.userid = username; // 如果使用Socks4代理，则使用userid字段
+                            else connectionOpts.authentication = { username, password };
+                        }
+
+                        // 创建SOCKS连接
+                        socksClient.createConnection(connectionOpts, (err, info) => {
+                            return err ? callback(err) : callback(null, { connection: info.socket || info });
+                        });
+                    };
+
+                    // 如果代理主机是IP地址，则直接连接
+                    if (isIP(hostname)) return connect(hostname);
+
+                    return dnsResolve(hostname, (err, address) => {
+                        if (err) return callback(err); // 如果出错，则直接返回
+                        connect(Array.isArray(address) ? address[0] : address);
+                    });
+                }
+            }
+            callback(new Error('未知代理配置'));
+        };
+    }
+
+    /**
+     * 转换数据URL图片为附件
+     * @param {Object} mail 邮件对象
+     * @param {Function} callback 回调函数
+     */
+    #convertDataImages(mail, callback) {
+        // 如果没有附件数据URL或没有HTML内容，则直接返回
+        if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) return callback();
+
+        // 解析HTML内容
+        mail.resolveContent(mail.data, 'html', (err, html = '') => {
+            if (err) return callback(err);
+            let imgCid = 0, ats;
+            const { attachments } = mail.data;
+
+            // 确保attachments是数组
+            if (!Array.isArray(attachments)) ats = mail.data.attachments = [].concat(attachments || []);
+            const rDUI = resetRegex(regexs.DATA_URL_IMAGE);
+            // 替换数据URL为CID引用
+            html = html.toString()
+                .replace(rDUI, (_match, prefix, dataUri, mimeType) => {
+                    // 添加附件
+                    const cid = `${randomBytes(10).toString('hex')}@localhost`;
+                    ats.push({ path: dataUri, cid, filename: `image-${++imgCid}.${detectExtension(mimeType)}` });
+                    return `${prefix}cid:${cid}`;
+                });
+            mail.data.html = html;
+            callback();
+        });
+    }
+
+    /**
+     * 设置元数据
+     * @param {*} key 键
+     * @param {*} value 值
+     */
+    set(key, value) {
+        return this.meta.set(key, value);
+    }
+
+    /**
+     * 获取元数据
+     * @param {*} key 键
+     */
+    get(key) {
+        return this.meta.get(key);
+    }
+}
+
+export { Mailer };