@flun/mailer 2.1.23 → 2.1.25

package/lib/fetch/index.js

@@ -35,7 +35,7 @@ const MAX_REDIRECTS = 5,              // 最大重定向次数常量
         let processedBody = null;
         const { contentType, body, headers } = options;
 
-        // 设置内容类型（除非明确禁止）
+        // 设置内容类型(除非明确禁止)
         if (contentType !== false) headers['Content-Type'] = contentType || 'application/x-www-form-urlencoded';
 
         // 流式数据处理
@@ -76,7 +76,7 @@ const MAX_REDIRECTS = 5,              // 最大重定向次数常量
             return true;
         }
 
-        // 准备重定向请求（GET方法，无请求体）
+        // 准备重定向请求(GET方法,无请求体)
         options.method = 'GET', options.body = false;
 
         try {
@@ -94,23 +94,26 @@ const MAX_REDIRECTS = 5,              // 最大重定向次数常量
  * >查看定义:@see {@link nmfetch}
  * @param {string} url - 请求的目标 URL;
  * @param {Object} [options={}] - 可选配置对象;
- * @param {stream.Writable} [options.fetchRes] - 用于写入响应数据的可写流，默认创建一个 PassThrough 流;
+ * @param {stream.Writable} [options.fetchRes] - 用于写入响应数据的可写流,默认创建一个 PassThrough 流;
  * @param {Cookies|Array|string} [options.cookies] - Cookie 管理器实例、Cookie 字符串数组或单个 Cookie 字符串,
  * 用于自动管理请求和响应的 Cookie;
- * @param {number} [options.redirects=0] - 已发生的重定向次数（内部使用）;
- * @param {number} [options.maxRedirects] - 允许的最大重定向次数，默认为 MAX_REDIRECTS 常量;
- * @param {string} [options.method=''] - HTTP 请求方法（如 'GET'、'POST' 等）,不提供时若存在请求体则默认为 'POST',否则为 'GET';
+ * @param {number} [options.redirects=0] - 已发生的重定向次数(内部使用);
+ * @param {number} [options.maxRedirects] - 允许的最大重定向次数,默认为 MAX_REDIRECTS 常量;
+ * @param {string} [options.method=''] - HTTP 请求方法(如 'GET'、'POST' 等),不提供时若存在请求体则默认为 'POST',
+ *否则为 'GET';
  * @param {Object} [options.headers] - 自定义请求头对象,键名会转为小写;
  * @param {string} [options.userAgent] - 自定义 User-Agent,会覆盖默认值;
- * @param {Object} [options.tls] - TLS/SSL 相关选项，直接传递给底层请求的 tls 配置;
- * @param {number} [options.timeout] - 请求超时时间（毫秒）,超时后触发错误并销毁请求;
- * @param {*} [options.body] - 请求体内容，可以是字符串、Buffer 或可读流；若存在且 method 未指定,则方法自动设为 'POST';
+ * @param {Object} [options.tls] - TLS/SSL 相关选项,直接传递给底层请求的 tls 配置;
+ * @param {number} [options.timeout] - 请求超时时间(毫秒),超时后触发错误并销毁请求;
+ * @param {*} [options.body] - 请求体内容,可以是字符串、Buffer 或可读流;若存在且 method 未指定,则方法自动设为 'POST';
  * @param {boolean} [options.allowErrorResponse=false] - 是否允许状态码 ≥300 的响应被视为成功,若为 false 则触发错误;
  *
- * @returns {stream.Writable} 返回用于接收响应数据的可写流（通常为 PassThrough 实例）,可通过监听 'finish' 或 'error' 事件获取结果;
+ * @returns {stream.Writable} 返回用于接收响应数据的可写流(通常为 PassThrough 实例),
+ *可通过监听 'finish' 或 'error' 事件获取结果;
  */
 const nmfetch = (url, options = {}) => {
-    const { fetchRes: fetchRes_, cookies, redirects = 0, maxRedirects, method = '', headers: headers_, userAgent, } = options,
+    const { fetchRes: fetchRes_, cookies, redirects = 0, maxRedirects,
+        method = '', headers: headers_, userAgent, } = options,
         // 设置默认响应流、Cookie管理器和重定向计数器
         fetchRes = fetchRes_ || new PassThrough(), newCookies = cookies || new Cookies();
     options.redirects = redirects, options.maxRedirects = isNaN(maxRedirects) ? MAX_REDIRECTS : maxRedirects;
@@ -123,7 +126,7 @@ const nmfetch = (url, options = {}) => {
     if (!parsedResult.success) return fetchRes;
     const { protocol, hostname: host, pathname, search = '', port, username, password } = parsedResult.result;
 
-    // 确定HTTP方法，默认为GET
+    // 确定HTTP方法,默认为GET
     let newMethod = method.toString().trim().toUpperCase() || 'GET';
     const handler = protocol === 'https:' ? https : http,
         // 设置默认请求头
@@ -132,8 +135,8 @@ const nmfetch = (url, options = {}) => {
     // 合并用户自定义头部
     Object.keys(headers_ || {}).forEach(key => headers[key.toLowerCase().trim()] = headers_[key]);
 
-    if (userAgent) headers['user-agent'] = userAgent; // 设置自定义User-Agent（如果提供）
-    // 如果URL中包含认证信息，则设置Authorization头
+    if (userAgent) headers['user-agent'] = userAgent; // 设置自定义User-Agent(如果提供)
+    // 如果URL中包含认证信息,则设置Authorization头
     if (username || password) {
         const auth = `${username}:${password}`;
         headers.Authorization = `Basic ${Buffer.from(auth).toString('base64')}`;
@@ -187,7 +190,7 @@ const nmfetch = (url, options = {}) => {
                     break;
             }
 
-            // 如果响应中的Set-Cookie头为真，则存储Cookie
+            // 如果响应中的Set-Cookie头为真,则存储Cookie
             const setCookie = res.headers['set-cookie'];
             if (setCookie) [].concat(setCookie).forEach(cookie => newCookies.set(cookie, url));
             if (_handleRedirect(res, url, options, fetchRes, finishedFlag, req)) return; // 处理重定向
@@ -204,7 +207,7 @@ const nmfetch = (url, options = {}) => {
                 _markFinishedWithError(finishedFlag, fetchRes, err, url), req.destroy();
             });
 
-            // 将响应流pipe到输出流，支持解压
+            // 将响应流pipe到输出流,支持解压
             if (inflate) {
                 res.pipe(inflate).pipe(fetchRes);
                 inflate.on('error', err => {
@@ -214,7 +217,7 @@ const nmfetch = (url, options = {}) => {
             else res.pipe(fetchRes);
         });
 
-    // 发送请求体（如果有）
+    // 发送请求体(如果有)
     setImmediate(() => {
         const body = bodyResult.body;
         if (body) {

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内容