@flun/mailer 2.1.24 → 2.1.25

package/lib/http-proxy-client.js

@@ -8,15 +8,15 @@ import { regexs } from './regexs.js';
 /**
  * 建立到目标端口的代理连接
  * >查看定义:@see {@link httpProxyClient}
- * - 使用示例：
+ * - 使用示例:
  * @example
  * httpProxyClient("http://localhost:3128/", 80, "google.com", (err, socket)=>{
  *     socket.write("GET / HTTP/1.0\r\n\r\n");
  * });
- * @param {String} proxyUrl 代理配置，例如 "http://proxy.host:3128/"
+ * @param {String} proxyUrl 代理配置,例如 "http://proxy.host:3128/"
  * @param {Number} destinationPort 目标主机端口
  * @param {String} destinationHost 目标主机名
- * @param {Function} callback 连接建立后的回调函数，接收socket对象
+ * @param {Function} callback 连接建立后的回调函数,接收socket对象
  */
 const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) => {
     let proxy;
@@ -27,7 +27,8 @@ const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) =
     }
 
     const { hostname, port, protocol, username = '', password = '' } = proxy, isHttps = protocol === 'https:',
-        options = { host: hostname, port: Number(port) || (isHttps ? 443 : 80), rejectUnauthorized: !isHttps }, // 配置连接选项
+        // 配置连接选项
+        options = { host: hostname, port: Number(port) || (isHttps ? 443 : 80), rejectUnauthorized: !isHttps },
         connect = isHttps ? (options, callback) => tlsConnect(options, callback)
             : (options, callback) => netConnect(options, callback), // 根据代理协议类型选择连接方式
         state = { finished: false },
@@ -53,7 +54,7 @@ const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) =
 
             // 构造CONNECT请求头(目标主机和端口,连接类型)
             const reqHeaders = { Host: `${destinationHost}:${destinationPort}`, Connection: 'close' };
-            // 如果代理需要认证，添加认证头
+            // 如果代理需要认证,添加认证头
             if (username || password) {
                 const auth = `${username}:${password}`;
                 reqHeaders['Proxy-Authorization'] = `Basic ${Buffer.from(auth).toString('base64')}`;
@@ -69,11 +70,13 @@ const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) =
                 if (state.finished) return;
 
                 headerChunks.push(chunk);  // 使用数组累积数据块
-                const headers = Buffer.concat(headerChunks).toString('latin1'), headersEndIndex = headers.indexOf('\r\n\r\n');
+                const headers = Buffer.concat(headerChunks).toString('latin1'),
+                headersEndIndex = headers.indexOf('\r\n\r\n');
                 if (headersEndIndex !== -1) {
                     socket.removeListener('data', onSocketData);
 
-                    const remainder = headers.substring(headersEndIndex + 4), headerPart = headers.substring(0, headersEndIndex),
+                    const remainder = headers.substring(headersEndIndex + 4),
+                    headerPart = headers.substring(0, headersEndIndex),
                         statusMatch = headerPart.match(regexs.HTTP_RESPONSE_STATUS_LINE);
 
                     if (remainder) socket.unshift(Buffer.from(remainder, 'latin1'));
@@ -81,7 +84,8 @@ const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) =
                     if (!statusMatch || (statusMatch[1]?.[0] ?? '') !== '2') {
                         try { socket.destroy(); } catch (E) { }
                         headerChunks = [];
-                        return callback(new Error(`代理服务器返回无效响应${((statusMatch && `: ${statusMatch[1]}`) || '')}`));
+                        const msg = `代理服务器返回无效响应${((statusMatch && `: ${statusMatch[1]}`) || '')}`;
+                        return callback(new Error(msg));
                     }
 
                     socket.removeListener('error', tempSocketErr).removeListener('timeout', timeoutErr).setTimeout(0);
@@ -92,7 +96,8 @@ const httpProxyClient = (proxyUrl, destinationPort, destinationHost, callback) =
             socket.on('data', onSocketData);
         });
 
-    socket.setTimeout(httpProxyClient.timeout || 30 * 1000).on('timeout', timeoutErr).once('error', tempSocketErr);//监听连接错误
+// 监听连接错误
+    socket.setTimeout(httpProxyClient.timeout || 30 * 1000).on('timeout', timeoutErr).once('error', tempSocketErr);
 }
 
 export { httpProxyClient };

package/lib/json-transport.js

@@ -8,8 +8,10 @@ import { PK, getLogger, prepareMessageForSending } from './shared.js';
  */
 class JsonTransport {
     constructor(options = {}) {
-        this.options = options, this.name = 'JsonTransport', this.version = PK.version;                  // 设置传输对象名称和版本
-        this.logger = getLogger(this.options, { component: this.options.component || 'jsonTransport' }); // 初始化日志记录器
+        // 设置传输对象名称和版本
+        this.options = options, this.name = 'JsonTransport', this.version = PK.version;
+        // 初始化日志记录器
+        this.logger = getLogger(this.options, { component: this.options.component || 'jsonTransport' });
     }
 
     /**
@@ -25,11 +27,13 @@ class JsonTransport {
         setImmediate(() => {
             normalize((err, data) => {
                 if (err) {
-                    this.logger.error({ err, tnx: 'send', messageId }, '为 %s 构建JSON结构失败: %s', messageId, err.message);
+                    this.logger.error({ err, tnx: 'send', messageId },
+                    '为 %s 构建JSON结构失败: %s', messageId, err.message);
                     return done(err);
                 }
                 delete data.envelope, delete data.normalizedHeaders;
-                return done(null, { envelope, messageId, message: this.options.skipEncoding ? data : JSON.stringify(data) });
+                return done(null,
+                    { envelope, messageId, message: this.options.skipEncoding ? data : JSON.stringify(data) });
             });
         });
     }

package/lib/mail-composer.js

@@ -3,7 +3,7 @@ import { regexs, resetRegex, parseDataURI } from './shared.js';
 import { detectMimeType, detectExtension } from './mime-funcs/index.js';
 /**
  * 邮件编译器类,用于从邮件选项组合MimeNode实例;
- * 负责处理邮件的多部分结构（纯文本、HTML、附件等）
+ * 负责处理邮件的多部分结构(纯文本、HTML、附件等)
  * >查看定义:@see {@link MailComposer}
  * @class MailComposer
  */
@@ -11,30 +11,32 @@ class MailComposer {
     constructor(mail = {}) { this.mail = mail, this.message = false; }
 
     /**
-     * 编译邮件内容，生成MimeNode实例
-     * 根据邮件内容类型（纯文本、HTML、附件等）构建相应的MIME结构
+     * 编译邮件内容,生成MimeNode实例
+     * 根据邮件内容类型(纯文本、HTML、附件等)构建相应的MIME结构
      * @returns {MimeNode} 编译后的MimeNode实例
      */
     compile() {
-        const aTives = this._alternatives = this.getAlternatives();  // 获取所有替代内容（纯文本、HTML、日历事件等）
+        const aTives = this._alternatives = this.getAlternatives();  // 获取所有替代内容(纯文本、HTML、日历事件等)
         // 从替代内容中提取HTML节点
         this._htmlNode = aTives.filter(alternative => regexs.HTML_TYPE.test(alternative.contentType)).pop();
-        // 获取附件，并根据是否存在HTML内容区分相关附件
+        // 获取附件,并根据是否存在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); // 是否需要混合部分（内容 + 附件）
+        this._useRelated = !!(this._htmlNode &&
+            related.length);                          // 是否需要相关部分(HTML + 内联图片)
+// 是否需要替代部分(纯文本 + HTML)
+        this._useAlternative = aTives.length > 1;
+        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 + 内联资源
+        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: '' });               // 简单类型：单一内容
+            .find(Boolean) || { contentType: 'text/plain', content: '' });               // 简单类型:单一内容
 
         if (headers) this.message.addHeader(headers);  // 添加自定义邮件头
         // 设置标准邮件头
@@ -53,8 +55,8 @@ class MailComposer {
 
     /**
      * 获取邮件附件列表
-     * 处理普通附件和相关附件（如内联图片）
-     * @param {boolean} findRelated - 是否查找相关附件（用于HTML内联）
+     * 处理普通附件和相关附件(如内联图片)
+     * @param {boolean} findRelated - 是否查找相关附件(用于HTML内联)
      * @returns {Object} 包含attached和related附件的对象
      */
     getAttachments(findRelated = false) {
@@ -63,7 +65,8 @@ class MailComposer {
 
         // 处理日历事件附件
         if (icalEvent) {
-            const iEvent = typeof icalEvent === 'object' && (icalEvent.content || icalEvent.path || icalEvent.href || icalEvent.raw)
+            const iEvent = typeof icalEvent === 'object' && (icalEvent.content || icalEvent.path || icalEvent.href ||
+                icalEvent.raw)
                 ? { ...icalEvent } : { content: icalEvent };
 
             eventObject = {
@@ -75,10 +78,12 @@ class MailComposer {
         // 处理所有附件
         const pAttachments = attachments.map((attachment, i) => {
             const pAtt = this.#prepareAttachmentObject(attachment), // 预处理附件
-                { filename, path, href, cid, raw, encoding, headers, contentType: cType, content = '', httpHeaders } = pAtt,
+                { 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'),
+                contentDisposition = pAtt.contentDisposition || (isMessageNode || (isImage &&
+                    cid) ? 'inline' : 'attachment'),
                 contentTransferEncoding = 'contentTransferEncoding' in pAtt ? pAtt.contentTransferEncoding
                     : isMessageNode ? '7bit' : 'base64',
                 // 构建附件数据
@@ -94,7 +99,7 @@ class MailComposer {
                     ? `${baseName}.${detectExtension(contentType)}` : baseName || `attachment-${i + 1}`;
             }
 
-            // 设置内容源（优先级：raw > path > href > content）
+            // 设置内容源(优先级:raw > path > href > content)
             if (!raw) data.content = path ? { path } : href ? { href, httpHeaders } : content;
             return data;
         }), eventArray = eventObject ? [eventObject] : [];
@@ -104,7 +109,7 @@ class MailComposer {
     }
 
     /**
-     * 获取邮件的替代内容（纯文本、HTML、日历事件等）
+     * 获取邮件的替代内容(纯文本、HTML、日历事件等)
      * 用于构建多部分替代结构
      * @returns {Array} 替代内容数组
      */
@@ -128,9 +133,11 @@ class MailComposer {
             const iEvent = processAlt(iEvent, icalEvent, null);
             eventObject = {
                 ...iEvent, filename: false,
-                contentType: `text/calendar; charset=utf-8; method=${(iEvent.method || 'PUBLISH').toString().trim().toUpperCase()}`,
+                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 } })
+                ...(iEvent.content && typeof iEvent.content === 'object' && { content: { ...iEvent.content,
+                    _resolve: true } })
             };
         }
 
@@ -141,13 +148,17 @@ class MailComposer {
         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,
+                    { 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 })
+                        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)
+// 设置内容源(优先级:raw>path>href>content)
+                if (!raw) data.content = path ? { path } : href ? { href } : content;
                 return data;
             });
 
@@ -155,30 +166,32 @@ class MailComposer {
     }
 
     /**
-     * 预处理附件对象（处理dataURL和标准化路径,将HTTP / HTTPS路径转换为href属性）
+     * 预处理附件对象(处理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 },
+        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则创建根节点
+     * 创建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());
+        return !parentNode ? this.#createRootMimeNode(mimeType) : parentNode.createChild(mimeType,
+            this.#getChildNodeOptions());
     }
 
     /**
-     * 创建混合类型的MIME节点（内容 + 附件）
+     * 创建混合类型的MIME节点(内容 + 附件)
      * @param {MimeNode} parentNode - 父节点
      * @returns {MimeNode} 创建的混合节点
      */
@@ -197,7 +210,7 @@ class MailComposer {
     }
 
     /**
-     * 创建替代类型的MIME节点（纯文本 + HTML）
+     * 创建替代类型的MIME节点(纯文本 + HTML)
      * @param {MimeNode} parentNode - 父节点
      * @returns {MimeNode} 创建的替代节点
      */
@@ -205,14 +218,15 @@ class MailComposer {
         const node = this.#createMimeNode(parentNode, 'multipart/alternative');
         // 添加所有替代内容
         this._alternatives.forEach(ative => {
-            this._useRelated && this._htmlNode === ative ? this.#createRelated(node) : this.#createContentNode(node, ative);
+            this._useRelated && this._htmlNode === ative ? this.#createRelated(node) : this.#createContentNode(node,
+                ative);
         });
 
         return node;
     }
 
     /**
-     * 创建相关类型的MIME节点（HTML + 内联资源）
+     * 创建相关类型的MIME节点(HTML + 内联资源)
      * @param {MimeNode} parentNode - 父节点
      * @returns {MimeNode} 创建的相关节点
      */
@@ -237,9 +251,10 @@ class MailComposer {
             { 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
+            filename, baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey,
+                newline
         }) : parentNode.createChild(contentType, {
             filename, textEncoding, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline
         });
@@ -274,7 +289,8 @@ class MailComposer {
         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 };
+        if (dataUrl.length > 100000) return { ...element, path: false, href: false, content: Buffer.alloc(0),
+            contentType };
 
         let parsedDataUri;
         try {
@@ -297,7 +313,8 @@ class MailComposer {
      * @returns {MimeNode} 创建的根节点
      */
     #createRootMimeNode(contentType) {
-        const { baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline } = this.mail;
+        const { baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey,
+            newline } = this.mail;
         return new MimeNode(contentType, {
             baseBoundary, textEncoding, boundaryPrefix, disableUrlAccess, disableFileAccess, normalizeHeaderKey, newline
         });

package/lib/mailer/index.js

@@ -18,13 +18,13 @@ class Mailer extends EventEmitter {
         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.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()); // 记录创建日志
@@ -44,7 +44,7 @@ class Mailer extends EventEmitter {
         ['close', 'isIdle', 'verify'].forEach(method => {
             this[method] = (...args) => {
                 if (typeof this.transporter[method] === 'function') {
-                    // 特殊处理verify方法，设置getSocket
+                    // 特殊处理verify方法,设置getSocket
                     if (method === 'verify' && typeof this.getSocket === 'function') this.#setupTransporterSocket();
                     return this.transporter[method](...args);
                 } else {
@@ -54,7 +54,7 @@ class Mailer extends EventEmitter {
             };
         });
 
-        if (proxy && typeof proxy === 'string') this.setupProxy(proxy); // 如果有代理，则设置代理
+        if (proxy && typeof proxy === 'string') this.setupProxy(proxy); // 如果有代理,则设置代理
     }
 
     /**
@@ -67,7 +67,7 @@ class Mailer extends EventEmitter {
 
     /**
      * 使用插件
-     * @param {string} step 插件阶段（'compile'或'stream'）
+     * @param {string} step 插件阶段('compile'或'stream')
      * @param {Function} plugin 插件函数
      */
     use(step = '', plugin) {
@@ -84,7 +84,7 @@ class Mailer extends EventEmitter {
      * @param {Function?} callback 发送成功或失败后运行的回调函数
      */
     sendMail(data, callback = null) {
-        // 如果没有提供回调，则创建Promise
+        // 如果没有提供回调,则创建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方法
@@ -150,26 +150,27 @@ class Mailer extends EventEmitter {
      */
     #processPlugins(step = '', mail, callback) {
         step = step.toString();
-        if (!this._userPlugins.hasOwnProperty(step)) return callback(); // 如果没有这个步骤，则直接返回
+        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) 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); // 如果插件返回错误，则直接返回
+                if (err) return callback(err); // 如果插件返回错误,则直接返回
                 processPlugins();
             });
         };
@@ -224,9 +225,9 @@ class Mailer extends EventEmitter {
                         if (auth) {
                             const username = decodeURIComponent(auth.split(':').shift()),
                                 password = decodeURIComponent(auth.split(':').pop());
-                            // 如果使用Socks5代理v2，则使用userId和password字段，否则使用authentication字段
+                            // 如果使用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 if (type === 4) connectionOpts.userid = username; // 如果使用Socks4代理,则使用userid字段
                             else connectionOpts.authentication = { username, password };
                         }
 
@@ -236,11 +237,11 @@ class Mailer extends EventEmitter {
                         });
                     };
 
-                    // 如果代理主机是IP地址，则直接连接
+                    // 如果代理主机是IP地址,则直接连接
                     if (isIP(hostname)) return connect(hostname);
 
                     return dnsResolve(hostname, (err, address) => {
-                        if (err) return callback(err); // 如果出错，则直接返回
+                        if (err) return callback(err); // 如果出错,则直接返回
                         connect(Array.isArray(address) ? address[0] : address);
                     });
                 }
@@ -255,7 +256,7 @@ class Mailer extends EventEmitter {
      * @param {Function} callback 回调函数
      */
     #convertDataImages(mail, callback) {
-        // 如果没有附件数据URL或没有HTML内容，则直接返回
+        // 如果没有附件数据URL或没有HTML内容,则直接返回
         if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) return callback();
 
         // 解析HTML内容

package/lib/mailer/mail-message.js

@@ -11,7 +11,7 @@ import { detectExtension, detectMimeType, isPlainText, encodeWord } from '../mim
  *  通常由 Mailer 实例内部创建和调用,不建议直接实例化;
  */
 class MailMessage {
-    // 构造函数，初始化邮件消息对象
+    // 构造函数,初始化邮件消息对象
     constructor(mailer, data = {}) {
         this.mailer = mailer, this.message = null;
         const { options = {}, _defaults = {} } = mailer;
@@ -22,37 +22,39 @@ class MailMessage {
         const headers = { ...defaults.headers, ...data.headers }, mailData = { ...defaults, ...data, headers };
         // 强制应用 transporter 选项中的特定键
         ['disableFileAccess', 'disableUrlAccess', 'normalizeHeaderKey'].forEach(key => {
-            if (key in options) mailData[key] = options[key]; // 如果在选项中设置，则使用选项值
+            if (key in options) mailData[key] = options[key]; // 如果在选项中设置,则使用选项值
         });
 
         return mailData;
     }
 
-    // 解析内容方法（代理给 resolveContent）
+    // 解析内容方法(代理给 resolveContent)
     resolveContent(...args) {
         return resolveContent(...args);
     }
 
-    // 解析所有内容（文本、HTML、附件等）
+    // 解析所有内容(文本、HTML、附件等)
     resolveAll(callback) {
         // 定义需要解析的内容键
         const keys = [
-            [this.data, 'html'], [this.data, 'text'], [this.data, 'watchHtml'], [this.data, 'amp'], [this.data, 'icalEvent']
+            [this.data, 'html'], [this.data, 'text'], [this.data, 'watchHtml'], [this.data, 'amp'],
+                [this.data, 'icalEvent']
         ], { alternatives, attachments } = this.data;
-        alternatives?.forEach((_, i) => keys.push([alternatives, i])); // 如果有替代内容，则添加到键中
+        alternatives?.forEach((_, i) => keys.push([alternatives, i])); // 如果有替代内容,则添加到键中
 
         // 处理附件
         attachments?.forEach((attachment, i) => {
             const { filename, path, href = '', contentType } = attachment;
             let newFname = filename;
-            // 如果没有文件名，则从路径或href中提取，或使用默认名称
+            // 如果没有文件名,则从路径或href中提取,或使用默认名称
             if (!newFname) {
                 newFname = (path || href).split('/').pop().split('?').shift() || `attachment-${(i + 1)}`;
-                if (!newFname.includes('.')) newFname += `.${detectExtension(contentType)}`; // 如果没有扩展名，则根据内容类型添加
+// 如果没有扩展名,则根据内容类型添加
+                if (!newFname.includes('.')) newFname += `.${detectExtension(contentType)}`;
                 attachment.filename = newFname; // 设置回attachment对象
             }
 
-            // 如果没有内容类型，则根据文件名、路径或href检测
+            // 如果没有内容类型,则根据文件名、路径或href检测
             if (!contentType) attachment.contentType = detectMimeType(newFname || path || href || 'bin');
             keys.push([attachments, i]);
         });
@@ -63,16 +65,16 @@ class MailMessage {
         addressKeys.forEach(address => {
             let value;
             const rAddress = this.message.getHeader(address === 'replyTo' ? 'reply-to' : address);
-            // 如果已有消息，从消息头解析地址
+            // 如果已有消息,从消息头解析地址
             if (this.message) value = [].concat(mimeNode.parseAddresses(rAddress) || []);
-            // 否则如果数据中有，则直接从数据中解析
+            // 否则如果数据中有,则直接从数据中解析
             else if (this.data[address]) value = [].concat(mimeNode.parseAddresses(this.data[address]) || []);
 
-            if (value?.length) this.data[address] = value;            // 如果有值，则保存到数据中
-            else if (address in this.data) this.data[address] = null; // 否则如果数据中有地址字段，则删除地址字段
+            if (value?.length) this.data[address] = value;            // 如果有值,则保存到数据中
+            else if (address in this.data) this.data[address] = null; // 否则如果数据中有地址字段,则删除地址字段
         });
 
-        // 处理单值地址字段（from, sender）;如果数据中有地址，则保存为地址对象
+        // 处理单值地址字段(from, sender);如果数据中有地址,则保存为地址对象
         ['from', 'sender'].forEach(address => {
             if (this.data[address]) this.data[address] = this.data[address].shift();
         });
@@ -87,11 +89,12 @@ class MailMessage {
             if (!parent || !currentItem) return resolveNext();       // 跳过空值
             resolveContent(...args, (err, value) => {
                 if (err) return callback(err);
-                const node = { content: value };                     // 创建内容节点，保留原始数据的其他属性
+                const node = { content: value };                     // 创建内容节点,保留原始数据的其他属性
                 if (currentItem && typeof currentItem === 'object' && !Buffer.isBuffer(currentItem))
                     Object.keys(currentItem).forEach(key => {
-                        // 如果没有在节点中，则从原始数据中复制属性
-                        if (!(key in node) && !['content', 'path', 'href', 'raw'].includes(key)) node[key] = currentItem[key];
+                        // 如果没有在节点中,则从原始数据中复制属性
+                        if (!(key in node) &&
+                            !['content', 'path', 'href', 'raw'].includes(key)) node[key] = currentItem[key];
                     });
 
                 parent[key] = node, resolveNext(); // 更新数据为节点对象并继续解析下一个
@@ -103,15 +106,16 @@ class MailMessage {
 
     // 规范化邮件数据
     normalize(callback) {
-        const envelope = this.data.envelope || this.message.getEnvelope(), messageId = this.message.messageId(); // 获取信封信息
+// 获取信封信息
+        const envelope = this.data.envelope || this.message.getEnvelope(), messageId = this.message.messageId();
         // 首先解析所有内容
         this.resolveAll((err, data) => {
-            if (err) return callback(err); // 如果解析失败，返回错误
+            if (err) return callback(err); // 如果解析失败,返回错误
 
             data.envelope = envelope, data.messageId = messageId; // 设置信封和消息ID
             ['html', 'text', 'watchHtml', 'amp'].forEach(key => {
                 const content = data[key]?.content;
-                // 如果内容不是是字符串，则转换为字符串,否则直接使用，
+                // 如果内容不是是字符串,则转换为字符串,否则直接使用,
                 if (content) data[key] = Buffer.isBuffer(content) ? content.toString() : content;
             });
 
@@ -158,7 +162,7 @@ class MailMessage {
 
     // 设置邮件发送器头部
     setMailerHeader() {
-        if (!this.message || !this.data.xMailer) return;        // 如果没有消息或没有xMailer，则直接返回
+        if (!this.message || !this.data.xMailer) return;        // 如果没有消息或没有xMailer,则直接返回
         this.message.setHeader('X-Mailer', this.data.xMailer);
     }
 
@@ -177,7 +181,7 @@ class MailMessage {
     // 设置列表头部
     setListHeaders() {
         const list = this.data.list;
-        if (!this.message || !list || typeof list !== 'object') return; // 如果没有消息或没有列表头部，则直接返回
+        if (!this.message || !list || typeof list !== 'object') return; // 如果没有消息或没有列表头部,则直接返回
 
         // 添加可选的 List-* 头部
         if (list && typeof list === 'object')
@@ -206,7 +210,7 @@ class MailMessage {
                                     url = formattedUrl.replace(regexs.LIST_ID_PROTOCOL_REMOVE, '');
                                 return quotedComment + url; // List-ID: "comment" <domain>
                             }
-                            // 返回格式化后的URL和注释（List-*: <http://domain> (comment)）
+                            // 返回格式化后的URL和注释(List-*: <http://domain> (comment))
                             return comment ? `${formattedUrl} (${comment})` : formattedUrl;
                         }).join(', ')
                 }]
@@ -218,7 +222,7 @@ class MailMessage {
         const rUC = resetRegex(regexs.URL_CLEAN);
         url = url.replace(rUC, '');                               // 去除空白和尖括号
         if (regexs.PROTOCOL_CHECK.test(url)) return `<${url}>`;   // 如果包含协议，则使用尖括号包裹
-        // 如果包含@，则使用mailto协议,否则使用HTTP协议
+        // 如果包含@,则使用mailto协议,否则使用HTTP协议
         return regexs.EMAIL_CHECK.test(url) ? `<mailto:${url}>` : `<http://${url}>`;
     }
 }