@flun/mailer 2.1.23 → 2.1.25

package/lib/mime-node/index.js

@@ -22,15 +22,15 @@ const B64 = 'base64', QP = 'quoted-printable';
  * 创建一个新的MIME树节点;如果是分支节点,假设内容类型为'multipart/*',
  * 其他任何内容类型都视为叶节点,如果选项中缺少rootNode,则假设此为根节点;
  * >查看定义:@see {@link MimeNode}
- * @param {String} contentType 定义节点的内容类型,对于附件可以留空（从文件名派生）
+ * @param {String} contentType 定义节点的内容类型,对于附件可以留空(从文件名派生)
  * @param {Object} [options] 可选选项
  * @param {Object} [options.rootNode] 此树的根节点
  * @param {Object} [options.parentNode] 此节点的直接父节点
  * @param {Object} [options.filename] 附件节点的文件名
  * @param {String} [options.baseBoundary] 唯一多部分边界值的共享部分
- * @param {Boolean} [options.keepBcc] 如果为true，不在生成的头部中排除Bcc
+ * @param {Boolean} [options.keepBcc] 如果为true,不在生成的头部中排除Bcc
  * @param {Function} [options.normalizeHeaderKey] 用于自定义头部键大小写规范化的方法
- * @param {String} [options.textEncoding] 编码类型：'Q'（默认）或'B'
+ * @param {String} [options.textEncoding] 编码类型:'Q'(默认)或'B'
  */
 class MimeNode {
     constructor(contentType, options = {}) {
@@ -50,25 +50,29 @@ class MimeNode {
         }
 
         this.newline = newline; // 如果设置为'win'则使用\r\n,如果为'linux'则使用\n;如果未设置(或使用`raw`),则换行符保持原样
-        this.textEncoding = textEncoding.toString().trim().charAt(0).toUpperCase(); // 指示头部字符串应使用的编码："Q"或"B"
-        this.parentNode = parentNode;                                               // 此节点的直接父节点(如果未设置则为undefined)
+        this.textEncoding = textEncoding.toString().trim().charAt(0).toUpperCase(); // 指示头部字符串应使用的编码:"Q"或"B"
+// 此节点的直接父节点(如果未设置则为undefined)
+        this.parentNode = parentNode;
         this.hostname = hostname;                                                   // 默认message - id值使用的主机名
 
         this.date = new Date();                                 // 当前日期
         this.childNodes = [];                                   // 可能的子节点数组
-        this._headers = [];                                     // 此节点的头部值列表，格式为[{ key: '', value: '' }]
-        this._transforms = [];                                  // 在通过createReadStream暴露之前，消息将被管道传输的额外转换流
-        this._processFuncs = [];                                // 在通过createReadStream暴露之前，消息将被管道传输的额外处理函数
-        this._nodeId = ++this.rootNode.nodeCounter;             // 用于生成唯一边界值（前缀添加到共享基础值之前）
+        this._headers = [];                                     // 此节点的头部值列表,格式为[{ key: '', value: '' }]
+// 在通过createReadStream暴露之前,消息将被管道传输的额外转换流
+        this._transforms = [];
+// 在通过createReadStream暴露之前,消息将被管道传输的额外处理函数
+        this._processFuncs = [];
+        this._nodeId = ++this.rootNode.nodeCounter;             // 用于生成唯一边界值(前缀添加到共享基础值之前)
         this._isPlainText = false;                              // 如果内容仅使用ASCII可打印字符则为true
         this._hasLongLines = false;                             // 如果内容是纯文本但有超过允许长度的行则为true
-        this._envelope = false;                                 // 如果设置，则使用此值作为信封而不是生成一个
-        this._raw = false;                                      // 如果设置，则使用此值作为流内容而不是构建它
-        if (contentType) this.setHeader('Content-Type', contentType); // 如果设置了内容类型(或从文件名派生),则将其添加到头部
+        this._envelope = false;                                 // 如果设置,则使用此值作为信封而不是生成一个
+        this._raw = false;                                      // 如果设置,则使用此值作为流内容而不是构建它
+// 如果设置了内容类型(或从文件名派生),则将其添加到头部
+        if (contentType) this.setHeader('Content-Type', contentType);
     }
 
     /**
-     * 创建并附加一个子节点。提供的参数传递给MimeNode构造函数
+     * 创建并附加一个子节点;提供的参数传递给MimeNode构造函数
      *
      * @param {String} [contentType] 可选内容类型
      * @param {Object} [options] 可选选项对象
@@ -127,11 +131,12 @@ class MimeNode {
             }
     }
 
-    // 统一处理头部操作，支持多种输入格式和操作类型
+    // 统一处理头部操作,支持多种输入格式和操作类型
     #processHeadersOp(key, value, singleOp, isSet) {
-        // 如果是批量操作（没有value且key是对象）
+        // 如果是批量操作(没有value且key是对象)
         if (!value && key && typeof key === 'object') {
-            // 允许{key:'content-type',value:'text/plain'},[{key:'content-type',value:'text/plain'}],{'content-type':'text/plain'}
+            // 允许{key:'content-type',value:'text/plain'},[{key:'content-type',value:'text/plain'}],
+            // {'content-type':'text/plain'}
             if (key.key && 'value' in key) singleOp.call(this, key.key, key.value);
             else if (Array.isArray(key)) key.forEach(i => singleOp.call(this, i.key, i.value));
             else Object.keys(key).forEach(i => singleOp.call(this, i, key[i]));
@@ -148,29 +153,29 @@ class MimeNode {
     }
 
     /**
-     * 设置头部值。如果选定键的值已存在，则会被覆盖。
-     * 可以使用[{key:'', value:''}]或{key: 'value'}作为第一个参数来设置多个值。
+     * 设置头部值;如果选定键的值已存在,则会被覆盖;
+     * 可以使用[{key:'', value:''}]或{key: 'value'}作为第一个参数来设置多个值;
      *
      * @param {String|Array|Object} key 头部键或键值对列表
      * @param {String} value 头部值
      * @return {Object} 当前节点
      */
     setHeader(key, value) {
-        // 如果未处理批量操作，说明是单个操作，已经在#processHeadersOp中处理完成
+        // 如果未处理批量操作,说明是单个操作,已经在#processHeadersOp中处理完成
         if (!this.#processHeadersOp(key, value, this.setHeader, true)); // true表示是set操作
         return this;
     }
 
     /**
-     * 添加头部值。如果选定键的值已存在，则值将作为新字段附加，旧字段不被触动。
-     * 您也可以使用[{key:'', value:''}]或{key: 'value'}作为第一个参数来设置多个值。
+     * 添加头部值;如果选定键的值已存在,则值将作为新字段附加,旧字段不被触动;
+     * 您也可以使用[{key:'', value:''}]或{key: 'value'}作为第一个参数来设置多个值;
      *
      * @param {String|Array|Object} key 头部键或键值对列表
      * @param {String} value 头部值
      * @return {Object} 当前节点
      */
     addHeader(key, value) {
-        // 如果未处理批量操作，说明是单个操作，已经在#processHeadersOp中处理完成
+        // 如果未处理批量操作,说明是单个操作,已经在#processHeadersOp中处理完成
         if (!this.#processHeadersOp(key, value, this.addHeader, false)); // false表示是add操作
         return this;
     }
@@ -188,8 +193,8 @@ class MimeNode {
     }
 
     /**
-     * 设置当前节点的正文内容。如果值是字符串，则自动将字符集添加到Content-Type（如果是text/*）。
-     * 如果值是Buffer，则需要自行指定字符集
+     * 设置当前节点的正文内容;如果值是字符串,则自动将字符集添加到Content-Type(如果是text/*);
+     * 如果值是Buffer,则需要自行指定字符集
      *
      * @param (String|Buffer) content 正文内容
      * @return {Object} 当前节点
@@ -197,14 +202,14 @@ class MimeNode {
     setContent(content) {
         this.content = content;
         if (typeof this.content.pipe === 'function') {
-            // 预流处理程序。如果流被设置为内容，并且在此流执行任何操作之前触发'error'，则可能被触发
+            // 预流处理程序;如果流被设置为内容,并且在此流执行任何操作之前触发'error',则可能被触发
             this.contentErrorHandler = err => {
                 this.content.removeListener('error', this.contentErrorHandler), this.content = err;
             };
             this.content.once('error', this.contentErrorHandler);
         } else if (typeof this.content === 'string') {
             this._isPlainText = isPlainText(this.content);
-            // 如果有超过76个符号/字节的行，则不使用7bit编码，而是使用8位编码。
+            // 如果有超过76个符号/字节的行,则不使用7bit编码,而是使用8位编码;
             if (this._isPlainText && hasLongerLines(this.content, 76)) this._hasLongLines = true;
         }
         return this;
@@ -212,7 +217,7 @@ class MimeNode {
 
     // 构建MIME树
     build(callback) {
-        // 如果没有回调，则返回一个承诺，该承诺将在构建完成时解析
+        // 如果没有回调,则返回一个承诺,该承诺将在构建完成时解析
         const promise = !callback ? new Promise((resolve, reject) => callback = callbackPromise(resolve, reject)) : null;
         resolveStream(this.createReadStream(), callback); // 将流数据读取到Buffer中
         return promise;
@@ -227,12 +232,14 @@ class MimeNode {
             encoding = (this.getHeader('Content-Transfer-Encoding') || '').toString().toLowerCase().trim();
             if (!encoding || ![B64, QP].includes(encoding)) {
                 if (regexs.TEXT_TYPE.test(contentType)) {
-                    if (this._isPlainText && !this._hasLongLines) encoding = '7bit';  // 如果没有特殊符号，则无需修改文本
-                    else if (typeof content === 'string' || content instanceof Buffer) // 否则,内容是字符串或Buffer,则用QP或Base64
+                    if (this._isPlainText && !this._hasLongLines) encoding = '7bit';  // 如果没有特殊符号,则无需修改文本
+// 否则,内容是字符串或Buffer,则用QP或Base64
+                    else if (typeof content === 'string' || content instanceof Buffer)
                         encoding = this.#getTextEncoding(content) === 'Q' ? QP : B64;
-                    else encoding = this.textEncoding === 'B' ? B64 : QP; // 否则,如果对于流,因无法检查内容,则使用首选编码或回退到QP
+// 否则,如果对于流,因无法检查内容,则使用首选编码或回退到QP
+                    else encoding = this.textEncoding === 'B' ? B64 : QP;
                 }
-                // 否则,如果不是 multipart 或 message 类型，默认使用 base64 编码
+                // 否则,如果不是 multipart 或 message 类型,默认使用 base64 编码
                 else if (!regexs.MULTIPART_OR_MESSAGE.test(contentType)) encoding = encoding || B64;
             }
         }
@@ -240,7 +247,7 @@ class MimeNode {
     }
 
     /**
-     * 构建MIME节点的头部块。在写入内容之前追加 \r\n\r\n
+     * 构建MIME节点的头部块;在写入内容之前追加 \r\n\r\n
      *
      * @returns {String} 头部
      */
@@ -265,9 +272,8 @@ class MimeNode {
         }
 
         this._headers.forEach(header => {
-            let structured, param, value = header.value;
-            const key = header.key, options = {},
-                formattedHeaders = ['From', 'Sender', 'To', 'Cc', 'Bcc', 'Reply-To', 'Date', 'References'];
+            let structured, param, value = header.value, key = header.key;
+            const options = {}, formattedHeaders = ['From', 'Sender', 'To', 'Cc', 'Bcc', 'Reply-To', 'Date', 'References'];
 
             if (value && typeof value === 'object' && !formattedHeaders.includes(key)) {
                 Object.keys(value).forEach(key => {
@@ -291,27 +297,29 @@ class MimeNode {
                     break;
                 case C_TYPE:
                     structured = parseHeaderValue(value), this.#handleContentType(structured);
-                    if (regexs.TEXT_PLAIN.test(structured.value) && typeof content === 'string' && regexs.NON_ASCII.test(content))
+                    if (regexs.TEXT_PLAIN.test(structured.value)
+                        && typeof content === 'string' && regexs.NON_ASCII.test(content))
                         structured.params.charset = 'utf-8';
 
                     value = buildHeaderValue(structured);
                     if (filename) {
-                        // 为非兼容客户端(如QQ网页邮件)添加支持,不能使用buildHeaderValue构建值,因为该值是非标准的,并且不支持参数;
+                        // 为非兼容客户端(如QQ网页邮件)添加支持,不能使用buildHeaderValue构建值,
+                        // 因为该值是非标准的,并且不支持参数;
                         param = this.#encodeWords(filename);
-                        // 如果参数与文件名匹配，则不添加参数。如果参数包含特殊字符，则添加引号。
+                        // 如果参数与文件名匹配,则不添加参数;如果参数包含特殊字符,则添加引号;
                         if (param !== filename || regexs.UNSAFE_PARAM_VALUE.test(param)) param = `"${param}"`;
                         value += `;name=${param}`;
                     }
                     break;
 
                 case 'Bcc':
-                    if (!this.keepBcc) return; // 如果不保留Bcc，则不添加头部
+                    if (!this.keepBcc) return; // 如果不保留Bcc,则不添加头部
                     break;
             }
 
             value = this.encodeHeaderValue(key, value);
             if (!value.toString().trim()) return; // 跳过空行
-            // 如果存在自定义的normalizeHeaderKey函数，则使用它来规范化头部键
+            // 如果存在自定义的normalizeHeaderKey函数,则使用它来规范化头部键
             if (typeof this.normalizeHeaderKey === 'function') {
                 let normalized = this.normalizeHeaderKey(key, value);
                 if (normalized && typeof normalized === 'string' && normalized.length) key = normalized;
@@ -324,8 +332,8 @@ class MimeNode {
     }
 
     /**
-     * 从当前节点流式传输rfc2822消息。如果这是根节点，
-     * 则设置缺失的必需头部字段（Date, Message-Id, MIME-Version）
+     * 从当前节点流式传输rfc2822消息;如果这是根节点,
+     * 则设置缺失的必需头部字段(Date, Message-Id, MIME-Version)
      *
      * @return {String} 编译后的消息 */
     createReadStream(options = {}) {
@@ -352,7 +360,7 @@ class MimeNode {
         // 在可能的用户转换之后确保终止换行符
         transform = new LastNewline(), outputStream = pipeStream(outputStream, transform);
 
-        // 循环遍历所有后处理函数，并将输出流传递给每个函数。
+        // 循环遍历所有后处理函数,并将输出流传递给每个函数;
         for (let i = 0; i < this._processFuncs.length; i++) {
             transform = this._processFuncs[i], outputStream = transform(outputStream);
         }
@@ -368,7 +376,7 @@ class MimeNode {
     }
 
     /**
-     * 将转换流对象附加到转换列表。最终输出在暴露之前通过此流传递
+     * 将转换流对象附加到转换列表;最终输出在暴露之前通过此流传递
      *
      * @param {Object} transform 读写流
      */
@@ -377,7 +385,7 @@ class MimeNode {
     }
 
     /**
-     * 附加后处理函数。该函数在转换之后运行，并使用以下语法
+     * 附加后处理函数;该函数在转换之后运行,并使用以下语法
      *
      *   processFunc(input) -> outputStream
      *
@@ -394,7 +402,7 @@ class MimeNode {
         const callback = args => {
             cleanup(state), done(args);
         },
-            // 对于多部分节点，推送子节点;对于内容节点，结束流
+            // 对于多部分节点,推送子节点;对于内容节点,结束流
             finalize = () => {
                 let childId = 0;
                 const processChildNode = () => {
@@ -417,7 +425,7 @@ class MimeNode {
             sendContent = () => {
                 const content = this.content;
                 if (content) {
-                    // 如果内容是错误，则直接调用回调
+                    // 如果内容是错误,则直接调用回调
                     if (Object.prototype.toString.call(content) === '[object Error]') return callback(content);
 
                     if (typeof content.pipe === 'function') {
@@ -456,12 +464,13 @@ class MimeNode {
 
         if (this._raw) {
             setImmediate(() => {
-                // 如果内容是错误，则直接调用回调;如果设置错误处理程序，则将其移除
+                // 如果内容是错误,则直接调用回调;如果设置错误处理程序,则将其移除
                 if (Object.prototype.toString.call(this._raw) === '[object Error]') return callback(this._raw);
                 if (typeof this._raw.pipe === 'function') this._raw.removeListener('error', this.contentErrorHandler);
 
                 const raw = this.#getStream(this._raw);
-                raw.pipe(outputStream, { end: false }), raw.on('end', finalize).on('error', err => outputStream.emit('error', err));
+                raw.pipe(outputStream, { end: false })
+                    , raw.on('end', finalize).on('error', err => outputStream.emit('error', err));
             });
         }
         else outputStream.write(`${this.buildHeaders()}\r\n\r\n`), setImmediate(sendContent);
@@ -470,7 +479,7 @@ class MimeNode {
     /**
      * 设置要使用的信封而不是生成的信封
      *
-     * @return {Object} SMTP信封，格式为 {from: 'from@example.com', to: ['to@example.com']}
+     * @return {Object} SMTP信封,格式为 {from: 'from@example.com', to: ['to@example.com']}
      */
     setEnvelope(envelope) {
         this._envelope = { from: false, to: [] };
@@ -483,11 +492,13 @@ class MimeNode {
 
         const { to } = this._envelope, standardFields = ['to', 'cc', 'bcc', 'from'];
         ['to', 'cc', 'bcc'].forEach(key => {
-            if (envelope[key]) this.#convertAddresses(this.parseAddresses(envelope[key]), to); // 如果存在，则将地址添加到信封中
+// 如果存在,则将地址添加到信封中
+            if (envelope[key]) this.#convertAddresses(this.parseAddresses(envelope[key]), to);
         });
         this._envelope.to = to.map(to => to.address).filter(address => address);
         Object.keys(envelope).forEach(key => {
-            if (!standardFields.includes(key)) this._envelope[key] = envelope[key];     // 如果字段不是标准字段,则将其添加到信封中
+// 如果字段不是标准字段,则将其添加到信封中
+            if (!standardFields.includes(key)) this._envelope[key] = envelope[key];
         });
 
         return this;
@@ -514,7 +525,7 @@ class MimeNode {
     /**
      * 生成并返回包含发件人地址和收件人地址列表的SMTP信封
      *
-     * @return {Object} SMTP信封，格式为 {from: 'from@example.com', to: ['to@example.com']}
+     * @return {Object} SMTP信封,格式为 {from: 'from@example.com', to: ['to@example.com']}
      */
     getEnvelope() {
         if (this._envelope) return this._envelope;
@@ -533,7 +544,7 @@ class MimeNode {
     }
 
     /**
-     * 返回Message-Id值。如果不存在，则创建一个
+     * 返回Message-Id值;如果不存在,则创建一个
      *
      * @return {String} Message-Id值
      */
@@ -542,14 +553,14 @@ class MimeNode {
     }
 
     /**
-     * 设置预生成的内容，该内容将用作此节点的输出
+     * 设置预生成的内容,该内容将用作此节点的输出
      *
      * @param {String|Buffer|Stream} 原始MIME内容
      */
     setRaw(raw) {
         this._raw = raw;
         if (this._raw && typeof this._raw.pipe === 'function') {
-            // 预流处理程序。如果流被设置为内容，并且在此流执行任何操作之前触发'error'，则可能被触发
+            // 预流处理程序;如果流被设置为内容,并且在此流执行任何操作之前触发'error',则可能被触发
             this.contentErrorHandler = err => {
                 this._raw.removeListener('error', this.contentErrorHandler), this._raw = err;
             };
@@ -560,7 +571,7 @@ class MimeNode {
     }
 
     /**
-     * 检测并返回与内容相关的流的句柄。
+     * 检测并返回与内容相关的流的句柄;
      *
      * @param {Mixed} content 节点内容
      * @returns {Object} 流对象
@@ -586,25 +597,26 @@ class MimeNode {
                 return stream;
             }, { _resolvedValue, pipe, path, href, httpHeaders } = content;
         if (_resolvedValue) return createContentStream(_resolvedValue);  // 处理已解析的字符串或Buffer类型内容
-        else if (typeof pipe === 'function') return content;             // 如果是流本身，则直接返回该流
-        // 如果是文件路径：根据访问权限返回文件流或错误流
+        else if (typeof pipe === 'function') return content;             // 如果是流本身,则直接返回该流
+        // 如果是文件路径:根据访问权限返回文件流或错误流
         else if (content && typeof path === 'string' && !href)
             return this.disableFileAccess ? createErrorStream(`文件访问被拒绝:${path}`) : fsReadStream(path);
-        // 如果是URL：根据访问权限返回网络流或错误流
+        // 如果是URL:根据访问权限返回网络流或错误流
         else if (content && typeof href === 'string')
-            return this.disableUrlAccess ? createErrorStream(`URL访问被拒绝:${href}`) : nmfetch(href, { headers: httpHeaders });
-        return createContentStream(content || '');                       // 兜底处理：将其他类型内容转换为流
+            return this.disableUrlAccess ? createErrorStream(`URL访问被拒绝:${href}`)
+                : nmfetch(href, { headers: httpHeaders });
+        return createContentStream(content || '');                       // 兜底处理:将其他类型内容转换为流
     }
 
     /**
-     * 解析地址。接受单个地址或数组或地址数组的数组（例如To: [[第一组], [第二组],...]）
+     * 解析地址;接受单个地址或数组或地址数组的数组(例如To: [[第一组], [第二组],...])
      *
      * @param {Mixed} addresses 要解析的地址
      * @return {Array} 地址对象数组
      */
     parseAddresses(addresses) {
         return [].concat.apply([], [].concat(addresses).map(mAddress => {
-            // 如果地址和名称都存在，则将其转换为数组
+            // 如果地址和名称都存在,则将其转换为数组
             if (mAddress?.address) {
                 const { address, name = '' } = mAddress;
                 mAddress.address = this.#normalizeAddress(address), mAddress.name = name;
@@ -615,7 +627,7 @@ class MimeNode {
     }
 
     /**
-     * 规范化头部键，使用驼峰式，除了大写的MIME-
+     * 规范化头部键,使用驼峰式,除了大写的MIME-
      *
      * @param {String} key 要规范化的键
      * @return {String} 驼峰式形式的键
@@ -630,8 +642,8 @@ class MimeNode {
     }
 
     /**
-     * 检查内容类型是否为多部分，并在需要时定义边界。
-     * 不返回任何内容，而是修改对象参数。
+     * 检查内容类型是否为多部分,并在需要时定义边界;
+     * 不返回任何内容,而是修改对象参数;
      *
      * @param {Object} structured 为'Content-Type'键解析的头部值
      */
@@ -651,14 +663,15 @@ class MimeNode {
     }
 
     /**
-     * 对生成的rfc2822电子邮件中使用的头部值进行编码。
+     * 对生成的rfc2822电子邮件中使用的头部值进行编码;
      *
      * @param {String} key 头部键
      * @param {String} value 头部值
      */
     encodeHeaderValue(key, value = '') {
         key = this.#normalizeHeaderKey(key);
-        const rL = resetRegex(regexs.LINEBREAKS), rAB = resetRegex(regexs.ANGLE_BRACKET), rBR = resetRegex(regexs.BLANK_REGEX),
+        const rL = resetRegex(regexs.LINEBREAKS), rAB = resetRegex(regexs.ANGLE_BRACKET),
+            rBR = resetRegex(regexs.BLANK_REGEX),
             cleanValue = (val = '') => {
                 return val.toString().replace(rL, ' '); // 将值转换为字符串，并替换掉换行符
             },
@@ -681,7 +694,7 @@ class MimeNode {
             case 'In-Reply-To':
             case 'Content-Id':
                 return ensureAngleBrackets(this.#encodeWords(cleanValue(value)));
-            // 用<>括起来的值，以空格分隔的列表
+            // 用<>括起来的值,以空格分隔的列表
             case 'References':
                 value = [].concat(value)
                     // 将值转换为字符串,删除尖括号中的空白字符,然后按空白字符分割
@@ -692,8 +705,8 @@ class MimeNode {
                 if (value instanceof Date) return value.toUTCString().replace('GMT', '+0000');
                 return this.#encodeWords(cleanValue(value));
             case 'Content-Type':
-            case 'Content-Disposition': return cleanValue(value); // 如果包含文件名，则已编码
-            default: return this.#encodeWords(cleanValue(value)); // 默认encodeWords仅在需要时编码，否则返回原始字符串
+            case 'Content-Disposition': return cleanValue(value); // 如果包含文件名,则已编码
+            default: return this.#encodeWords(cleanValue(value)); // 默认encodeWords仅在需要时编码,否则返回原始字符串
         }
     }
 
@@ -735,7 +748,7 @@ class MimeNode {
         address = address.toString().replace(rFC, ' ').trim();
 
         const lIndex = address.lastIndexOf('@');
-        if (lIndex < 0) return address; // 没有@符号，保持原样
+        if (lIndex < 0) return address; // 没有@符号,保持原样
 
         let user = address.substring(0, lIndex), encodedDomain;
         const domain = address.substring(lIndex + 1);
@@ -755,9 +768,9 @@ class MimeNode {
 
     /**
      * 对邮件地址中的名称部分进行编码处理
-     * 如果名称包含非ASCII字符或特殊字符，则进行MIME编码或引号包裹
+     * 如果名称包含非ASCII字符或特殊字符,则进行MIME编码或引号包裹
      *
-     * @param {String} name 邮件地址中的名称部分（如 "张三" in "张三<zhangsan@example.com>"）
+     * @param {String} name 邮件地址中的名称部分(如 "张三" in "张三<zhangsan@example.com>")
      * @returns {String} 编码后的名称字符串
      */
     #encodeAddressName(name) {
@@ -789,7 +802,7 @@ class MimeNode {
      */
     #getTextEncoding(value = '') {
         value = value.toString();
-        if (this.textEncoding) return this.textEncoding;  // 如果有预设编码，直接返回
+        if (this.textEncoding) return this.textEncoding;  // 如果有预设编码,直接返回
         const rNL = resetRegex(regexs.NON_LATIN), rL = resetRegex(regexs.LATIN),
             nonLatinLen = (value.match(rNL) || []).length, latinLen = (value.match(rL) || []).length;
         return nonLatinLen < latinLen ? 'Q' : 'B';
@@ -801,7 +814,7 @@ class MimeNode {
      * @return {String} 随机Message-ID值
      */
     #generateMessageId() {
-        // 使用不同长度的随机字节生成类似UUID的格式,优先使用发件人地址中的域名，服务器主机名或localhost次之
+        // 使用不同长度的随机字节生成类似UUID的格式,优先使用发件人地址中的域名,服务器主机名或localhost次之
         const randomPart = [4, 2, 2, 2, 6].map(len => randomBytes(len).toString('hex')).join('-'),
             domain = (this.getEnvelope().from || this.hostname || 'localhost').split('@').pop();
         return `<${randomPart}@${domain}>`; // 返回符合RFC标准的Message-ID格式

package/lib/mime-node/last-newline.js

@@ -18,8 +18,8 @@ class LastNewline extends Transform {
      * @param {function} done - 完成回调
      */
     _transform(chunk, encoding, done) {
-        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);   // 如果是字符串，转换为Buffer
-        if (chunk.length) this.lastByte = chunk.at(-1);                        // 如果数据块不为空，记录最后一个字节
+        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);   // 如果是字符串,转换为Buffer
+        if (chunk.length) this.lastByte = chunk.at(-1);                        // 如果数据块不为空,记录最后一个字节
         this.push(chunk), done(); // 将数据块推送到下一个流;完成
     }
 
@@ -28,9 +28,9 @@ class LastNewline extends Transform {
      * @param {function} done - 完成回调
      */
     _flush(done) {
-        if (this.lastByte === 0x0a) return done();  // 如果最后一个字节是换行符，直接结束
+        if (this.lastByte === 0x0a) return done();  // 如果最后一个字节是换行符,直接结束
 
-        // 如果最后一个字节是回车符，添加换行符
+        // 如果最后一个字节是回车符,添加换行符
         if (this.lastByte === 0x0d) {
             this.push(Buffer.from('\n'));
             return done();

package/lib/mime-node/le-unix.js

@@ -27,9 +27,9 @@ class LeUnix extends Transform {
             if (chunk[i] === 0x0d) buf = chunk.subarray(lastPos, i), lastPos = i + 1, this.push(buf);
         }
 
-        // 如果剩余数据为真，则推送最后一个回车符之后的数据
+        // 如果剩余数据为真,则推送最后一个回车符之后的数据
         if (lastPos && lastPos < chunk.length) buf = chunk.subarray(lastPos), this.push(buf);
-        else if (!lastPos) this.push(chunk); // 否则, 如果没有找到回车符，直接推送整个数据块
+        else if (!lastPos) this.push(chunk); // 否则, 如果没有找到回车符,直接推送整个数据块
         done();
     }
 }

package/lib/mime-node/le-windows.js

@@ -8,17 +8,17 @@ import { Transform } from 'stream';
 class LeWindows extends Transform {
     constructor(options = {}) {
         super(options);
-        this.options = options, this.lastByte = false;  // 记录上一个字节，用于跨 chunk 的换行符检测
+        this.options = options, this.lastByte = false;  // 记录上一个字节,用于跨 chunk 的换行符检测
     }
 
     /**
-     * 转换函数：确保所有换行符都是 \r\n 格式
+     * 转换函数:确保所有换行符都是 \r\n 格式
      */
     _transform(chunk, encoding, done) {
         if (chunk.length === 0) return done();
         if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);  // 如果chunk是字符串,根据encoding转换为Buffer
 
-        // 快速路径：无换行符直接推送
+        // 快速路径:无换行符直接推送
         if (!chunk.includes(0x0a)) {
             this.push(chunk), this.lastByte = chunk.at(-1);
             return done();