@flun/mailer 2.1.23 → 2.1.25

package/lib/punycode.js

@@ -1,10 +1,10 @@
 /**
   Punycode.js
-  主要功能包括：
-  1.将Unicode字符串转换为Punycode字符串（仅包含ASCII字符）。
-  2.将Punycode字符串转换回Unicode字符串。
-  3.处理域名或电子邮件地址的转换，其中只有非ASCII部分会被转换。
-  4.将Unicode字符串转换为Punycode字符串，并将结果附加到域名或电子邮件地址的非ASCII部分之前。
+  主要功能包括:
+  1.将Unicode字符串转换为Punycode字符串(仅包含ASCII字符);
+  2.将Punycode字符串转换回Unicode字符串;
+  3.处理域名或电子邮件地址的转换,其中只有非ASCII部分会被转换;
+  4.将Unicode字符串转换为Punycode字符串,并将结果附加到域名或电子邮件地址的非ASCII部分之前;
 */
 import { regexs, resetRegex, } from './regexs.js';
 
@@ -14,7 +14,8 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = '-',
     /** 错误消息 */
     errors = {
-        overflow: '溢出：输入需要更宽的整数来处理', 'not-basic': '非法输入 >= 0x80（不是基本码点）', 'invalid-input': '无效输入'
+        overflow: '溢出:输入需要更宽的整数来处理', 'not-basic': '非法输入 >= 0x80(不是基本码点)',
+            'invalid-input': '无效输入'
     },
     /** 便捷缩写 */
     baseMinusTMin = base - tMin, floor = Math.floor, strFromCharCode = String.fromCharCode, // 字符代码转字符串函数
@@ -46,7 +47,7 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     },
 
     /**
-     * 一个简单的类似 `Array#map` 的包装器，用于处理域名字符串或电子邮件地址
+     * 一个简单的类似 `Array#map` 的包装器,用于处理域名字符串或电子邮件地址
      * @private
      * @param {String} domain 域名或电子邮件地址
      * @param {Function} callback 为每个字符调用的函数
@@ -55,9 +56,9 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     mapDomain = (domain, callback) => {
         const parts = domain.split('@');
         let result = '';
-        // 在电子邮件地址中，只有域名部分应进行punycode编码。保持本地部分（即`@`之前的所有内容）不变
+        // 在电子邮件地址中,只有域名部分应进行punycode编码;保持本地部分(即`@`之前的所有内容)不变
         if (parts.length > 1) result = `${parts[0]}@`, domain = parts[1];
-        // 为了IE8兼容性，避免使用`split(regex)`;参见 #17
+        // 为了IE8兼容性,避免使用`split(regex)`;参见 #17
         const rS = resetRegex(regexs.SEPARATORS);
         domain = domain.replace(rS, '\x2E');
         const encoded = map(domain.split('.'), callback).join('.');
@@ -65,13 +66,13 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     },
 
     /**
-     * 创建一个包含字符串中每个Unicode字符的数字码点的数组。
-     * 虽然JavaScript内部使用UCS-2，但此函数会将一对代理半部（UCS-2将每个半部公开为单独的字符）
-     * 转换为单个码点，以匹配UTF-16。
+     * 创建一个包含字符串中每个Unicode字符的数字码点的数组;
+     * 虽然JavaScript内部使用UCS-2,但此函数会将一对代理半部(UCS-2将每个半部公开为单独的字符)
+     * 转换为单个码点,以匹配UTF-16;
      * @see `punycode.ucs2.encode`
      * @memberOf punycode.ucs2
      * @name decode
-     * @param {String} string Unicode输入字符串（UCS-2）
+     * @param {String} string Unicode输入字符串(UCS-2)
      * @returns {Array} 新的码点数组
      */
     ucs2decode = string => {
@@ -79,7 +80,7 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
         let counter = 0;
         while (counter < length) {
             const value = string.charCodeAt(counter++); // 获取当前字符的UTF-16代码单元
-            // 如果是高代理项（范围：0xD800-0xDBFF）并且不是最后一个字符
+            // 如果是高代理项(范围:0xD800-0xDBFF)并且不是最后一个字符
             if (value >= 0xd800 && value <= 0xdbff && counter < length) {
                 const extra = string.charCodeAt(counter++); // 获取下一个字符
                 // 如果下一个字符是低代理项,则添加代理项对;否则,仅添加高代理项并回退计数器
@@ -92,53 +93,56 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     },
 
     /**
-     * 基于数字码点数组创建字符串。
+     * 基于数字码点数组创建字符串;
      * @see `punycode.ucs2.decode`
      * @memberOf punycode.ucs2
      * @name encode
      * @param {Array} codePoints 数字码点数组
-     * @returns {String} 新的Unicode字符串（UCS-2）
+     * @returns {String} 新的Unicode字符串(UCS-2)
      */
     ucs2encode = codePoints => {
         return String.fromCodePoint(...codePoints);
     },
 
     /**
-     * 将基本码点转换为数字/整数。
+     * 将基本码点转换为数字/整数;
      * @see `digitToBasic()`
      * @private
      * @param {Number} codePoint 基本数字码点值
-     * @returns {Number} 基本码点的数值（用于表示整数），范围从`0`到`base - 1`，如果码点不表示值，则返回`base`
+     * @returns {Number} 基本码点的数值(用于表示整数),范围从`0`到`base - 1`,如果码点不表示值,则返回`base`
      */
     basicToDigit = codePoint => {
 
-        if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);//如码点在`0x30`到`0x39`范围内(`0'-`9`),则返回其数值;
-        if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;      // 如码点在`0x41`到`0x5a`范围内(`A`-`Z`),则返回其数值;
-        if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;      // 如码点在`0x61`到`0x7a`范围内(`a`-`z`),则返回其数值;
+//如码点在`0x30`到`0x39`范围内(`0'-`9`),则返回其数值;
+        if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);
+// 如码点在`0x41`到`0x5a`范围内(`A`-`Z`),则返回其数值;
+        if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;
+// 如码点在`0x61`到`0x7a`范围内(`a`-`z`),则返回其数值;
+        if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;
         return base; // 不在基本字符范围内
     },
 
     /**
-     * 将数字/整数转换为基本码点。
+     * 将数字/整数转换为基本码点;
      * @see `basicToDigit()`
      * @private
      * @param {Number} digit 基本码点的数值
-     * @returns {Number} 其值（用于表示整数）为`digit`的基本码点，需要在`0`到`base - 1`范围内。
-     *                   如果`flag`非零，则使用大写形式；否则使用小写形式。
-     *                   如果`flag`非零且`digit`没有大写形式，则行为未定义。
+     * @returns {Number} 其值(用于表示整数)为`digit`的基本码点,需要在`0`到`base - 1`范围内;
+     *                   如果`flag`非零,则使用大写形式;否则使用小写形式;
+     *                   如果`flag`非零且`digit`没有大写形式,则行为未定义;
      */
     digitToBasic = (digit, flag) => {
         return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
     },
 
     /**
-     * 根据 RFC 3492 第 3.4 节的偏差适应函数。
+     * 根据 RFC 3492 第 3.4 节的偏差适应函数;
      * https://tools.ietf.org/html/rfc3492#section-3.4
      * @private
      */
     adapt = (delta, numPoints, firstTime) => {
         let k = 0;
-        delta = firstTime ? floor(delta / damp) : delta >> 1; // 首次处理时除以阻尼因子，否则右移一位
+        delta = firstTime ? floor(delta / damp) : delta >> 1; // 首次处理时除以阻尼因子,否则右移一位
         delta += floor(delta / numPoints);
         for (; /* 无初始化 */ delta > (baseMinusTMin * tMax) >> 1; k += base) delta = floor(delta / baseMinusTMin);
 
@@ -146,14 +150,14 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     },
 
     /**
-     * 将仅包含ASCII符号的Punycode字符串转换为Unicode符号字符串。
+     * 将仅包含ASCII符号的Punycode字符串转换为Unicode符号字符串;
      * @memberOf punycode
      * @param {String} input 仅包含ASCII符号的Punycode字符串
      * @returns {String} 生成的Unicode符号字符串
      */
     decode = input => {
         const output = [], inputLen = input.length;
-        // 当前码点值,初始码点,初始偏差,处理基本ASCII字符（分隔符前的部分）
+        // 当前码点值,初始码点,初始偏差,处理基本ASCII字符(分隔符前的部分)
         let i = 0, n = initialN, bias = initialBias, basic = input.lastIndexOf(delimiter);
         if (basic < 0) basic = 0;
 
@@ -190,24 +194,25 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
             const out = output.length + 1;
             bias = adapt(i - oldi, out, oldi === 0);
             if (Math.floor(i / out) > maxInt - n) throw new Error(overflow); // 更新码点值并插入到输出
-            n += Math.floor(i / out), i %= out, output.splice(i, 0, n), i++; // 在指定位置插入解码后的字符,并移动到下一个插入位置
+// 在指定位置插入解码后的字符,并移动到下一个插入位置
+            n += Math.floor(i / out), i %= out, output.splice(i, 0, n), i++;
         }
 
         return String.fromCodePoint(...output);
     },
 
     /**
-     * 将Unicode符号字符串（例如域名标签）转换为仅包含ASCII符号的Punycode字符串。
+     * 将Unicode符号字符串(例如域名标签)转换为仅包含ASCII符号的Punycode字符串;
      * @memberOf punycode
      * @param {String} input Unicode符号字符串
      * @returns {String} 生成的仅包含ASCII符号的Punycode字符串
      */
     encode = input => {
-        input = ucs2decode(input);                        // 将UCS-2输入转换为Unicode码点数组。
+        input = ucs2decode(input);                        // 将UCS-2输入转换为Unicode码点数组;
         const output = [], inputLen = input.length;       // 缓存长度
         let n = initialN, delta = 0, bias = initialBias;  // 初始化状态
 
-        // 处理基本码点。
+        // 处理基本码点;
         for (const currentValue of input)
             if (currentValue < 0x80) output.push(strFromCharCode(currentValue));
 
@@ -215,14 +220,14 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
         let handledCPCount = basicLen;        // `handledCPCount`是已处理的码点数量;`basicLength`是基本码点的数量;
         if (basicLen) output.push(delimiter); // 用分隔符结束基本字符串,除非它是空的;
 
-        // 主编码循环：
+        // 主编码循环:
         while (handledCPCount < inputLen) {
-            // 所有小于 n 的非基本码点都已处理。找到下一个更大的：
+            // 所有小于 n 的非基本码点都已处理;找到下一个更大的:
             let m = maxInt;
             for (const currentValue of input)
                 if (currentValue >= n && currentValue < m) m = currentValue;
 
-            // 增加 `delta` 足够多，以将解码器的 <n,i> 状态推进到 <m,0>，但要防止溢出。
+            // 增加 `delta` 足够多,以将解码器的 <n,i> 状态推进到 <m,0>,但要防止溢出;
             const handledCPCountPlusOne = handledCPCount + 1;
             if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) error('overflow');
 
@@ -230,14 +235,15 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
             for (const currentValue of input) {
                 if (currentValue < n && ++delta > maxInt) error('overflow');
                 if (currentValue === n) {
-                    // 将 delta 表示为广义可变长度整数。
+                    // 将 delta 表示为广义可变长度整数;
                     let q = delta;
                     for (let k = base /* 无条件 */; ; k += base) {
                         const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                         if (q < t) break;
 
                         const qMinusT = q - t, baseMinusT = base - t;
-                        output.push(strFromCharCode(digitToBasic(t + (qMinusT % baseMinusT), 0))), q = floor(qMinusT / baseMinusT);
+                        output.push(strFromCharCode(digitToBasic(t + (qMinusT % baseMinusT), 0))),
+                            q = floor(qMinusT / baseMinusT);
                     }
 
                     output.push(strFromCharCode(digitToBasic(q, 0)));
@@ -250,8 +256,8 @@ const maxInt = 2147483647, // 即 0x7FFFFFFF 或 2^31-1
     },
 
     /**
-     * 将表示域名或电子邮件地址的Punycode字符串转换为Unicode。
-     * 只有输入的Punycode部分会被转换，即如果你在已经转换为Unicode的字符串上调用它也没有关系。
+     * 将表示域名或电子邮件地址的Punycode字符串转换为Unicode;
+     * 只有输入的Punycode部分会被转换,即如果你在已经转换为Unicode的字符串上调用它也没有关系;
      * @memberOf punycode
      * @param {String} input 要转换为Unicode的Punycode编码的域名或电子邮件地址
      * @returns {String} 给定Punycode字符串的Unicode表示

package/lib/qp.js

@@ -10,7 +10,7 @@ import { regexs, resetRegex } from './regexs.js';
  */
 const qpWrap = (str = '', lineLength = 76) => {
     str = str.toString();
-    if (str.length <= lineLength) return str;  // 如果字符串长度不超过行限制，直接返回
+    if (str.length <= lineLength) return str;  // 如果字符串长度不超过行限制,直接返回
     let pos = 0, match, code, line, result = '';
     const len = str.length, lineMargin = Math.floor(lineLength / 3),
         // 将行添加到结果中并更新位置
@@ -25,7 +25,7 @@ const qpWrap = (str = '', lineLength = 76) => {
             continue;
         }
 
-        // 如果以换行符结尾，保持不变
+        // 如果以换行符结尾,保持不变
         if (line.endsWith('\n')) {
             addLineAndUpdatePos(line);
             continue;
@@ -34,15 +34,18 @@ const qpWrap = (str = '', lineLength = 76) => {
             line = line.slice(0, line.length - (match[0].length - 1)), addLineAndUpdatePos(line); // 截断到最近的换行符
             continue;
         }
-        else if (line.length > lineLength - lineMargin && (match = line.slice(-lineMargin).match(regexs.TRAILING_SPACE_OR_PUNCTUATION)))
+        else if (line.length > lineLength - lineMargin &&
+            (match = line.slice(-lineMargin).match(regexs.TRAILING_SPACE_OR_PUNCTUATION)))
             line = line.slice(0, line.length - (match[0].length - 1));  // 截断到最近的空格
         else if (line.match(regexs.INCOMPLETE_ENCODING)) {
             // 将不完整的编码序列推到下一行
-            if ((match = line.match(regexs.INCOMPLETE_ENCODING_SHORT))) line = line.slice(0, line.length - match[0].length);
+            if ((match = line.match(regexs.INCOMPLETE_ENCODING_SHORT)))
+                line = line.slice(0, line.length - match[0].length);
 
             const rCE = resetRegex(regexs.COMPLETE_ENCODING);
             // 确保UTF-8序列不被分割
-            while (line.length > 3 && line.length < len - pos && !line.match(regexs.UTF8_ENCODING) && (match = line.match(rCE))) {
+            while (line.length > 3 && line.length < len - pos &&
+                !line.match(regexs.UTF8_ENCODING) && (match = line.match(rCE))) {
                 code = parseInt(match[0].slice(1, 3), 16);
                 if (code < 128) break;
 
@@ -68,17 +71,18 @@ const qpWrap = (str = '', lineLength = 76) => {
 },
 
     /**
-     * 辅助函数：检查数字是否在指定范围内
+     * 辅助函数:检查数字是否在指定范围内
      *
      * @param {Number} nr 要检查的数字
      * @param {Array} ranges 允许的值范围数组
-     * @returns {Boolean} 如果在允许范围内返回true，否则返回false
+     * @returns {Boolean} 如果在允许范围内返回true,否则返回false
      */
     checkRanges = (nr, ranges) => {
         for (let i = ranges.length - 1; i >= 0; i--) {
-            if (!ranges[i].length) continue;                                 // 如果范围为空，则跳过
-            if (ranges[i].length === 1 && nr === ranges[i][0]) return true;  // 如果范围只有一个值，则直接比较
-            if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) return true;// 如果范围有两个值,则比较是否在范围内
+            if (!ranges[i].length) continue;                                 // 如果范围为空,则跳过
+            if (ranges[i].length === 1 && nr === ranges[i][0]) return true;  // 如果范围只有一个值,则直接比较
+// 如果范围有两个值,则比较是否在范围内
+            if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) return true;
         }
         return false;
     };
@@ -90,7 +94,7 @@ const qpWrap = (str = '', lineLength = 76) => {
  * @returns {String} Quoted-Printable编码的字符串
  */
 const qpEncode = buffer => {
-    if (typeof buffer === 'string') buffer = Buffer.from(buffer, 'utf-8'); // 如果输入是字符串，先转换为Buffer
+    if (typeof buffer === 'string') buffer = Buffer.from(buffer, 'utf-8'); // 如果输入是字符串,先转换为Buffer
 
     // 不需要编码的可用字符范围
     const ranges = [
@@ -105,13 +109,13 @@ const qpEncode = buffer => {
     for (let i = 0, len = buffer.length; i < len; i++) {
         const ord = buffer[i], nextByte = buffer[i + 1];
 
-        // 如果字符在允许范围内，并且不是行尾的空格或制表符，则直接使用原字符
+        // 如果字符在允许范围内,并且不是行尾的空格或制表符,则直接使用原字符
         if (checkRanges(ord, ranges) && !((ord === 0x20 || ord === 0x09) && (i === len - 1 || nextByte === 0x0a
             || nextByte === 0x0d))) {
             result += String.fromCharCode(ord);
             continue;
         }
-        result += `=${(ord < 0x10 ? '0' : '')}${ord.toString(16).toUpperCase()}`; // 否则进行编码：=后跟两位十六进制数
+        result += `=${(ord < 0x10 ? '0' : '')}${ord.toString(16).toUpperCase()}`; // 否则进行编码:=后跟两位十六进制数
     }
 
     return result;
@@ -154,13 +158,13 @@ class QpEncoder extends Transform {
 
             if (qp) this.outputBytes += qp.length, this.push(qp);
         }
-        // 否则没有启用行长度限制，直接编码并输出
+        // 否则没有启用行长度限制,直接编码并输出
         else qp = qpEncode(chunk), this.outputBytes += qp.length, this.push(qp, 'ascii');
         done();
     }
 
     /**
-     * 刷新流，输出剩余数据
+     * 刷新流,输出剩余数据
      */
     _flush(done) {
         if (this._curLine) this.outputBytes += this._curLine.length, this.push(this._curLine, 'ascii');

package/lib/regexs.js

@@ -6,28 +6,28 @@ const regexs = {
     LINE_SEPARATOR: /\r?\n/,                                // 按行分割丢弃换行符
     SPLIT_KEEP_NEWLINE: /(\r?\n)/,                          // 按行分割并保留行结束符
     LINE_BREAK: /^[^\n\r]*(\r?\n|\r)/,                      // 匹配行结束符
-    INVALID_ADDRESS_CHARS: /[\r\n<>]/,                      // 匹配地址中的非法字符（回车、换行、<>）
+    INVALID_ADDRESS_CHARS: /[\r\n<>]/,                      // 匹配地址中的非法字符(回车、换行、<>)
     WHITESPACE: /\s+/,                                      // 匹配空白字符
-    FOLDED_HEADER_LINE: /^\s/,                              // 匹配折叠的头信息行（以空白字符开头）
+    FOLDED_HEADER_LINE: /^\s/,                              // 匹配折叠的头信息行(以空白字符开头)
     RESPONSE_CODE: /^(\d+)(?:\s(\d+\.\d+\.\d+))?\s/,        // 匹配SMTP响应代码和可选状态码
     NEXT_WORD: /^[^\s]+(\s*)/,                              // 匹配下一个单词及其后的空白
-    ADDRESS_CLEAN: /^[^<]*<\s*/,                            // 地址令牌清理：清理地址令牌中的多余字符
-    EMAIL_LOOSE: /\s*\b[^@\s]+@[^\s]+\b\s*/,                // 邮箱地址宽松匹配：匹配文本中可能包含特殊字符的邮箱地址
+    ADDRESS_CLEAN: /^[^<]*<\s*/,                            // 地址令牌清理:清理地址令牌中的多余字符
+    EMAIL_LOOSE: /\s*\b[^@\s]+@[^\s]+\b\s*/,                // 邮箱地址宽松匹配:匹配文本中可能包含特殊字符的邮箱地址
     UNSAFE_PARAM_VALUE: /[\s'"\\;:/=(),<>@[\]?]|^-/,        // 匹配参数值中的不安全字符或以连字符开头
 
-    TRAILING_WSP: /[ \t]+$/,                                // 匹配行尾空白字符（WSP）
+    TRAILING_WSP: /[ \t]+$/,                                // 匹配行尾空白字符(WSP)
     OPTIONAL_CRLF: /\r?\n$/,                                // 匹配可选的CRLF行结束符
     TRAILING_NEWLINE: /\n.*?$/,                             // 匹配行尾的换行符及其后的内容
-    LAST_LINE: /(^|\n)([^\n]*)$/,                           // 匹配最后一行（用于换行处理）
+    LAST_LINE: /(^|\n)([^\n]*)$/,                           // 匹配最后一行(用于换行处理)
     EMAIL_CHECK: /^[^@]+@[^@]+$/,                           // 检查电子邮件格式
     TRAILING_SPACES: /(\s+)[^\s]*$/,                        // 匹配行尾的空白字符及其后的非空白字符
-    EMAIL_EXACT: /^[^@\s]+@[^@\s]+$/,                       // 邮箱地址精确匹配：匹配简单的邮箱格式（名称@域名）
+    EMAIL_EXACT: /^[^@\s]+@[^@\s]+$/,                       // 邮箱地址精确匹配:匹配简单的邮箱格式(名称@域名)
     PRINTABLE_ASCII: /^[\x20-\x7e]*$/,                      // 匹配可打印ASCII字符
     CRAM_MD5_CHALLENGE: /^334\s+(.+)$/,                     // 匹配CRAM-MD5挑战字符串
     TRAILING_LINE_BREAK: /(?:\r\n|\r|\n)$/,                 // 检测字符串是否以行结束符结尾
-    RFC2231_KEY: /(\*(\d+)|\*(\d+)\*|\*)$/,                 // 匹配RFC2231格式的参数键名（带星号和编号）
+    RFC2231_KEY: /(\*(\d+)|\*(\d+)\*|\*)$/,                 // 匹配RFC2231格式的参数键名(带星号和编号)
     RALPHANUMERIC_UNDERSCORE_SPACE: /^[\w ]*$/,             // 匹配仅包含字母数字、下划线和空格的字符串
-    CHARSET_LANGUAGE_VALUE: /^([^']*)'[^']*'(.*)$/,         // 匹配字符集、语言和值的格式（RFC2231）
+    CHARSET_LANGUAGE_VALUE: /^([^']*)'[^']*'(.*)$/,         // 匹配字符集、语言和值的格式(RFC2231)
     IPV4_ADDRESS: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/,   // 匹配IPv4地址格式
     UNSAFE_HEADER_PARAM: /[\s"\\;:/=(),<>@[\]?]|^[-']|'$/,  // 匹配头参数值中的不安全字符
     TRAILING_SPACE_OR_PUNCTUATION: /[ \t.,!?][^ \t.,!?]*$/, // 匹配空格、制表符或标点符号以及其后的非空格、非标点符号字符
@@ -38,32 +38,32 @@ const regexs = {
     TEXT_TYPE: /^text\//i,                                  // 匹配所有text/*内容类型
     IMAGE_TYPE: /^image\//i,                                // 检测图像内容类型
     HTTP_URL: /^https?:\/\//i,                              // 检测HTTP/HTTPS协议
-    ERROR_SUFFIX: /Error\]$/i,                              // 匹配以"Error]"结尾的字符串（不区分大小写）
+    ERROR_SUFFIX: /Error\]$/i,                              // 匹配以"Error]"结尾的字符串(不区分大小写)
     MULTIPART: /^multipart\//i,                             // 匹配multipart/*内容类型
     HTML_TYPE: /^text\/html\b/i,                            // 检测HTML内容类型
     MESSAGE_TYPE: /^message\//i,                            // 检测消息内容类型
-    ENCODED_SEQUENCE: /^[=]([0-9A-F]{2})/i,                 // 匹配编码序列（等号后跟2个十六进制数字）
+    ENCODED_SEQUENCE: /^[=]([0-9A-F]{2})/i,                 // 匹配编码序列(等号后跟2个十六进制数字)
     CONTENT_FEATURES: /^Content-Features$/i,                // 匹配Content-Features头部
-    UTF8_ENCODING: /^(?:=[\da-f]{2}){1,4}$/i,               // 匹配UTF-8编码序列（1-4个连续的编码字节）
-    INCOMPLETE_ENCODING: /[=][\da-f]{0,2}$/i,               // 匹配不完整的编码序列（等号后跟0-2个十六进制数字）
+    UTF8_ENCODING: /^(?:=[\da-f]{2}){1,4}$/i,               // 匹配UTF-8编码序列(1-4个连续的编码字节)
+    INCOMPLETE_ENCODING: /[=][\da-f]{0,2}$/i,               // 匹配不完整的编码序列(等号后跟0-2个十六进制数字)
     INCOMPLETE_ENCODING_END: /[=][0-9A-F]?$/i,              // 匹配字符串末尾的不完整编码序列
-    TRANSPORTER_PROTOCOL: /^(smtps?|direct):/i,             // 匹配传输器协议（smtp://, smtps://, direct://）
-    INCOMPLETE_ENCODING_SHORT: /[=][\da-f]{0,1}$/i,         // 匹配更短的不完整编码序列（等号后跟0-1个十六进制数字）
+    TRANSPORTER_PROTOCOL: /^(smtps?|direct):/i,             // 匹配传输器协议(smtp://, smtps://, direct://)
+    INCOMPLETE_ENCODING_SHORT: /[=][\da-f]{0,1}$/i,         // 匹配更短的不完整编码序列(等号后跟0-1个十六进制数字)
     MULTIPART_OR_MESSAGE: /^(multipart|message)\//i,        // 匹配multipart/*或message/*内容类型
     HTTP_RESPONSE_STATUS_LINE: /^HTTP\/\d+\.\d+ (\d+)/i,    // 匹配 HTTP 响应状态行
     AUTH_MECHANISM: /[ -]AUTH(?:(\s+|=)[^\n]*\s+|\s+|=)/i,  // 匹配AUTH机制
     IPV6_ADDRESS: /^(?:[A-F0-9]{1,4}:){7}[A-F0-9]{1,4}$/i,  // 匹配IPv6地址格式
 
-    NON_ASCII: /\P{ASCII}/u,                                // 匹配非ASCII字符（Unicode字符）
-    NON_BASIC_ASCII: /[^\x00-\x7F]/,                        // 检测非基本ASCII字符（编码>127）
+    NON_ASCII: /\P{ASCII}/u,                                // 匹配非ASCII字符(Unicode字符)
+    NON_BASIC_ASCII: /[^\x00-\x7F]/,                        // 检测非基本ASCII字符(编码>127)
     PROTOCOL_CHECK: /^(https?|mailto|ftp):/,                // 检查URL协议
     LIST_ID_PROTOCOL_REMOVE: /^<[^:]+\/{,2}/,               // 移除List-ID中的协议部分
-    UTF16_HIGH_SURROGATE: /[\uD800-\uDBFF]/,                // 匹配UTF-16高代理项（代理对的第一部分）
+    UTF16_HIGH_SURROGATE: /[\uD800-\uDBFF]/,                // 匹配UTF-16高代理项(代理对的第一部分)
     EMOJI_OR_SURROGATE: /[\ud83c\ud83d\ud83e]/,             // 匹配emoji或UTF-16代理对起始字符
-    PLAIN_TEXT: /[^\x09\x0a\x0d\x20-\x7e]/,                 // 匹配非可打印7位ASCII字符（允许\t\n\r和\x20-\x7e）
-    PARAM_PLAIN_TEXT: /[^\x09\x0a\x0d\x20-\x7e]|"/,         // 匹配非可打印字符或双引号（参数校验用）
+    PLAIN_TEXT: /[^\x09\x0a\x0d\x20-\x7e]/,                 // 匹配非可打印7位ASCII字符(允许\t\n\r和\x20-\x7e)
+    PARAM_PLAIN_TEXT: /[^\x09\x0a\x0d\x20-\x7e]|"/,         // 匹配非可打印字符或双引号(参数校验用)
     FIRST_NON_ASCII_WORD: /(?:^|\s)([^\s]*[^\x00-\x7F])/,   // 匹配第一个包含非ASCII字符的单词
-    NEED_ENCODING: /[\x00-\x20\x2B\x3D\x7F]|[^\x21-\x7E]/,  // 不可打印ASCII字符（包括非ASCII字符）
+    NEED_ENCODING: /[\x00-\x20\x2B\x3D\x7F]|[^\x21-\x7E]/,  // 不可打印ASCII字符(包括非ASCII字符)
 
     DSN: /[ -]DSN\b/im,                                      // 匹配DSN扩展支持
     STARTTLS: /[ -]STARTTLS\b/im,                            // 匹配STARTTLS扩展支持
@@ -84,28 +84,28 @@ const regexs = {
     NON_DIGIT: /\D/g,                                       // 匹配非数字字符
     CID_CLEAN: /[<>]/g,                                     // 清理Content-ID中的尖括号
     BLANK_REGEX: /\s/g,                                     // 匹配所有空白字符
-    URL_SAFE_BASE64: /\W/g,                                 // 匹配非单词字符（非字母、数字、下划线）
+    URL_SAFE_BASE64: /\W/g,                                 // 匹配非单词字符(非字母、数字、下划线)
     MULTIPLE_WSP: /[ \t]+/g,                                // 匹配行内多个空白字符
-    LINEBREAKS: /\r?\n|\r/g,                                // 匹配各种换行符（CRLF、LF、CR）
-    QUOTED_PAIR: /([\\"])/g,                                // 匹配需要转义的字符（反斜杠和引号）
+    LINEBREAKS: /\r?\n|\r/g,                                // 匹配各种换行符(CRLF、LF、CR)
+    QUOTED_PAIR: /([\\"])/g,                                // 匹配需要转义的字符(反斜杠和引号)
     HYPHEN_REPLACE: /-(\w)/g,                               // 连字符替换为驼峰命名
     ANGLE_BRACKET: /<[^>]*>/g,                              // 匹配尖括号内的内容
     GLOBAL_WHITESPACE: /\s+/g,                              // 匹配多个连续空白字符为单个空格
     ENCODING_FORMAT: /[-_\s]/g,                             // 格式化编码字符串
-    CLEAN_MESSAGE_ID: /[<>\s]/g,                            // 清理message-id头，移除尖括号和空白字符
+    CLEAN_MESSAGE_ID: /[<>\s]/g,                            // 清理message-id头,移除尖括号和空白字符
     GLOBAL_CRLF_OR_LF: /\r?\n/g,                            // 匹配CRLF或LF换行符
     URL_CLEAN: /[\s<]+|[\s>]+/g,                            // 清理URL中的空白和尖括号
-    RFC2231_SPECIAL_CHARS: /[=?_\s]/g,                      // RFC2231编码中需要转义的特殊字符：等号、问号、下划线和空白字符
-    FORBIDDEN_CHARS: /[\x00-\x1F<>]+/g,                     // 匹配控制字符和尖括号（不允许的字符）
+    RFC2231_SPECIAL_CHARS: /[=?_\s]/g,                      // RFC2231编码中需要转义的特殊字符:等号、问号、下划线和空白字符
+    FORBIDDEN_CHARS: /[\x00-\x1F<>]+/g,                     // 匹配控制字符和尖括号(不允许的字符)
     SEPARATORS: /[\x2E\u3002\uFF0E\uFF61]/g,                // RFC 3490 分隔符
     NON_ALPHANUMERIC_DOT_HYPHEN: /[^a-zA-Z0-9.-]/g,         // 匹配非字母数字、点号和连字符的字符
     SIGNATURE_FOLDING: /(^.{73}|.{75}(?!\r?\n|\r))/g,       // 签名折行处理正则
-    NON_LATIN: /[\x00-\x08\x0B\x0C\x0E-\x1F\P{ASCII}]/gu,   // 匹配非拉丁字符（控制字符和Unicode）
+    NON_LATIN: /[\x00-\x08\x0B\x0C\x0E-\x1F\P{ASCII}]/gu,   // 匹配非拉丁字符(控制字符和Unicode)
     NON_SAFE_URI: /[^\x00-\x1F *'()<>@,;:\\"[\]?=\u007F-\uFFFF]+/g,    // 匹配URI中的不安全字符范围
     NON_SAFE_URI_CHAR: /[\x00-\x1F *'()<>@,;:\\"[\]?=\u007F-\uFFFF]/g, // 匹配单个URI不安全字符
     LATIN: /[a-z]/gi,                                       // 匹配拉丁字母
-    NON_SAFE_CHAR: /[^a-z0-9!*+\-/=]/gi,                    // 匹配非安全字符（用于QP编码）
-    COMPLETE_ENCODING: /[=][\da-f]{2}$/gi,                  // 匹配完整的编码序列（等号后跟2个十六进制数字）
+    NON_SAFE_CHAR: /[^a-z0-9!*+\-/=]/gi,                    // 匹配非安全字符(用于QP编码)
+    COMPLETE_ENCODING: /[=][\da-f]{2}$/gi,                  // 匹配完整的编码序列(等号后跟2个十六进制数字)
     DATA_URL_IMAGE: /(]{0,1024} src\s{0,20}=[\s"']{0,20})(data:([^;]+);[^"'>\s]+)/gi, // 匹配HTML中的data URL图片
     NORMALIZE_HEADER_KEY: /^X-SMTPAPI$|^(MIME|DKIM|ARC|BIMI)\b|^[a-z]|-(SPF|FBL|ID|MD5)$|-[a-z]/gi, // 头部键规范化规则
 };

package/lib/sendmail-transport.js

@@ -4,7 +4,7 @@ import { PK, getLogger, prepareMessageForSending, cleanup } from './shared.js';
 /**
  * 生成Sendmail传输对象
  *
- * 可用的选项如下：
+ * 可用的选项如下:
  *  **path** sendmail二进制文件的可选路径
  *  **newline** 换行符类型,可以是'windows'或'unix'
  *  **args** sendmail二进制文件的参数数组
@@ -24,8 +24,8 @@ class SendmailTransport {
 
         // 根据选项配置参数
         if (options) {
-            if (typeof options === 'string') this.path = options;  // 如果options是字符串，直接作为sendmail路径
-            // 否则,如果options是对象，检查path和args属性
+            if (typeof options === 'string') this.path = options;  // 如果options是字符串,直接作为sendmail路径
+            // 否则,如果options是对象,检查path和args属性
             else if (typeof options === 'object') {
                 const { path, args, newline = '' } = options;
                 if (path) this.path = path;

package/lib/ses-transport.js

@@ -23,7 +23,7 @@ class SesTransport extends EventEmitter {
      */
     getRegion(cb) {
         const regionFunc = this.ses.sesClient.config?.region;
-        // 如果是函数，则调用该函数并返回结果,否则返回结果
+        // 如果是函数,则调用该函数并返回结果,否则返回结果
         return typeof regionFunc === 'function' ? regionFunc().then(r => cb(null, r)).catch(cb) : cb(null, false);
     }
 
@@ -50,14 +50,16 @@ class SesTransport extends EventEmitter {
              */
             getRawMessage = next => {
                 // 在 DKIM 签名中不使用 Message-ID 和 Date; 将流数据读取到Buffer中
-                const sF = _dkim.skipFields, dMsgId = 'date:message-id', stream = readStream.pipe(new LeWindows()); // 创建消息流
-                _dkim.skipFields = (sF && typeof sF === 'string') ? `${sF}:${dMsgId}` : dMsgId, resolveStream(stream, next);
+// 创建消息流
+                const sF = _dkim.skipFields, dMsgId = 'date:message-id', stream = readStream.pipe(new LeWindows());
+                _dkim.skipFields = (sF && typeof sF === 'string') ? `${sF}:${dMsgId}` : dMsgId,
+                    resolveStream(stream, next);
             };
 
         // 异步执行发送过程
         setImmediate(() =>
             getRawMessage((err, raw) => {
-                if (err) return handleError(err, '为 %s 创建消息失败。%s');
+                if (err) return handleError(err, '为 %s 创建消息失败;%s');
 
                 // 构建 SES 消息对象(添加自定义参数: ses)
                 const sesMessage = {
@@ -86,19 +88,21 @@ class SesTransport extends EventEmitter {
      * 验证 SES 配置
      *
      * @param {Function} callback 回调函数
-     * @return {Promise} 如果没有提供回调函数，则返回 Promise
+     * @return {Promise} 如果没有提供回调函数,则返回 Promise
      */
     verify(callback) {
         const promise = !callback ? new Promise((resolve, reject) => callback = callbackPromise(resolve, reject)) : null,
-            // 忽略某些特定错误，仍然认为验证成功
+            // 忽略某些特定错误,仍然认为验证成功
             cb = err => callback(
-                err && !['InvalidParameterValue', 'MessageRejected'].includes(err?.code || err?.Code || err?.name) ? err : null, true
+                err && !['InvalidParameterValue', 'MessageRejected'].includes(err?.code || err?.Code || err?.name)
+                    ? err : null, true
             ),
 
             iEmail = 'invalid@invalid',
             // 创建测试用的无效消息
             sesMessage = {
-                Content: { Raw: { Data: Buffer.from(`From: <${iEmail}>\r\nTo: <${iEmail}>\r\nSubject: Invalid\r\n\r\nInvalid`) } },
+                Content: { Raw: { Data: Buffer.from(
+                        `From: <${iEmail}>\r\nTo: <${iEmail}>\r\nSubject: Invalid\r\n\r\nInvalid`) } },
                 FromEmailAddress: iEmail, Destination: { ToAddresses: [iEmail] }
             };