@flun/mailer 2.1.23 → 2.1.25

package/lib/addressparser.js

@@ -9,7 +9,7 @@ class Tokenizer {
     constructor(str = '') {
         this.str = str.toString(), this.operatorExpecting = '', this.node = null, this.escaped = false, this.list = [];
 
-        // 操作符映射：开始操作符到期望的结束操作符(引号,注释,邮件地址,地址分隔符,组定义开始,组定义结束)
+        // 操作符映射:开始操作符到期望的结束操作符(引号,注释,邮件地址,地址分隔符,组定义开始,组定义结束)
         this.operators = { '"': '"', '(': ')', '<': '>', ',': '', ':': ';', ';': '' };
     }
 
@@ -35,9 +35,9 @@ class Tokenizer {
     }
 
     /**
-     * 处理单个字符，识别操作符或文本内容
+     * 处理单个字符,识别操作符或文本内容
      * @param {String} chr 当前字符
-     * @param {String} nextChr 下一个字符（用于前瞻）
+     * @param {String} nextChr 下一个字符(用于前瞻)
      */
     #processChar(chr, nextChr) {
         const { escaped, operatorExpecting: oExpecting, operators } = this;
@@ -47,7 +47,7 @@ class Tokenizer {
         // 检查是否是新的开始操作符
         else if (!escaped && !oExpecting && chr in operators) return this.#addOperatorToken(chr, nextChr, operators[chr]);
 
-        // 检查转义字符（在引号或注释中）
+        // 检查转义字符(在引号或注释中)
         else if (!escaped && ['"', "'"].includes(oExpecting) && chr === '\\') return this.escaped = true;
         this.#addTextChar(chr), this.escaped = false;  // 处理文本字符并重置转义标志
     }
@@ -55,12 +55,12 @@ class Tokenizer {
     /**
      * 添加操作符令牌到列表
      * @param {String} chr 操作符字符
-     * @param {String} nextChr 下一个字符（用于设置noBreak标志）
+     * @param {String} nextChr 下一个字符(用于设置noBreak标志)
      * @param {String} newExpecting 新的期望操作符
      */
     #addOperatorToken(chr, nextChr, newExpecting = '') {
         const node = { type: 'operator', value: chr };
-        // 如果下一个字符不是空白或分隔符，设置noBreak标志
+        // 如果下一个字符不是空白或分隔符,设置noBreak标志
         if (nextChr && ![' ', '\t', '\r', '\n', ',', ';'].includes(nextChr)) node.noBreak = true;
         this.list.push(node), this.node = null, this.escaped = false, this.operatorExpecting = newExpecting;
     }
@@ -70,15 +70,17 @@ class Tokenizer {
      * @param {String} chr 文本字符
      */
     #addTextChar(chr) {
-        if (!this.node) this.node = { type: 'text', value: '' }, this.list.push(this.node); // 如果没有当前文本节点,则创建一个新的
+        if (!this.node)
+            this.node = { type: 'text', value: '' }, this.list.push(this.node); // 如果没有当前文本节点,则创建一个新的
 
         const processedChr = chr === '\n' ? ' ' : chr; // 规范化空白字符
-        if (chr.charCodeAt(0) >= 0x21 || [' ', '\t'].includes(chr)) this.node.value += processedChr;// 如果是可见字符或空格,则添加
+        if (chr.charCodeAt(0) >= 0x21 || [' ', '\t'].includes(chr))
+            this.node.value += processedChr; // 如果是可见字符或空格,则添加
     }
 }
 
 /**
- * 如果文本数据为空但存在注释数据，则用注释数据替换文本数据
+ * 如果文本数据为空但存在注释数据,则用注释数据替换文本数据
  * @param {Object} data 包含文本和注释数据的对象
  * @return {Object} 处理后的数据对象
  */
@@ -127,7 +129,7 @@ const _replaceTextWithComment = data => {
         let isGroup = false, state = 'text';
         const data = { address: [], comment: [], group: [], text: [] };
 
-        // 解析令牌，分类到地址、注释、组或文本
+        // 解析令牌,分类到地址、注释、组或文本
         for (let i = 0; i < tokens.length; i++) {
             const token = tokens[i], prevToken = i ? tokens[i - 1] : null;
             if (token.type === 'operator')
@@ -150,24 +152,26 @@ const _replaceTextWithComment = data => {
                 // 清理地址令牌中的多余字符(如未引用的名称中的"<")
                 if (state === 'address') token.value = token.value.replace(regexs.ADDRESS_CLEAN, '');
 
-                // 如果前一个令牌设置了noBreak，则附加到最后一个元素,否则创建新的元素
+                // 如果前一个令牌设置了noBreak,则附加到最后一个元素,否则创建新的元素
                 const dLen = data[state].length;
                 prevToken?.noBreak && dLen ? data[state][dLen - 1] += token.value : data[state].push(token.value);
             }
         }
-        const { text, group, address } = _replaceTextWithComment(data);             // 如果没有文本但有注释，用注释替换文本
-        // 如果组存在，处理组地址：组名和组成员列表
+        const { text, group, address } = _replaceTextWithComment(data);             // 如果没有文本但有注释,用注释替换文本
+        // 如果组存在,处理组地址:组名和组成员列表
         if (isGroup) return [{ name: text.join(' ') || '', group: group.length ? addressparser(group.join(',')) : [] }];
         else {
-            if (!address.length && text.length) _extractEmailFromText(data);         // 如果没有地址，从文本中提取电子邮件地址
+            if (!address.length && text.length)
+                _extractEmailFromText(data); // 如果没有地址,从文本中提取电子邮件地址
 
             const { text: newTxt, address: newAdd } = _replaceTextWithComment(data); // 再次检查是否需要将注释转换为文本
-            if (newAdd.length > 1) newTxt.push(...newAdd.splice(1));                 // 如果找到多个地址,只保留第一个,其余的转到文本数组
+            if (newAdd.length > 1)
+                newTxt.push(...newAdd.splice(1)); // 如果找到多个地址,只保留第一个,其余的转到文本数组
             const addressText = newTxt.join(' ').trim(), addressValue = newAdd.join(' ').trim(),// 合并文本和地址数据
                 // 创建地址对象
                 addressObj = { address: addressValue || addressText || '', name: addressText || addressValue || '' };
 
-            // 如果地址和名称相同，根据内容决定清除哪个(如果是邮件地址,清除名称,否则,清除地址)
+            // 如果地址和名称相同,根据内容决定清除哪个(如果是邮件地址,清除名称,否则,清除地址)
             if (addressObj.address === addressObj.name)
                 addressObj.address.includes('@') ? addressObj.name = '' : addressObj.address = '';
 
@@ -213,7 +217,7 @@ const addressparser = (str, options = {}) => {
         if (address.length) parsedAddresses = parsedAddresses.concat(address);
     });
 
-    // 如果要求展平，将组地址转换为平面列表
+    // 如果要求展平,将组地址转换为平面列表
     if (options.flatten) {
         const flattenedAddresses = [],
             walkAddressList = list => {

package/lib/base64.js

@@ -25,9 +25,10 @@ const base64Encode = buffer => {
         let pos = 0;
         const result = [], chunkLength = lineLength * 1024;
 
-        // 每行最多允许lineLength个字符，每1024行进行一次处理
+        // 每行最多允许lineLength个字符,每1024行进行一次处理
         while (pos < str.length) {
-            const end = pos + chunkLength, wLines = str.substring(pos, end).replace(new RegExp(`.{${lineLength}}`, 'g'), '$&\r\n');
+            const end = pos + chunkLength,
+                wLines = str.substring(pos, end).replace(new RegExp(`.{${lineLength}}`, 'g'), '$&\r\n');
             result.push(wLines), pos = end;
         }
 
@@ -39,7 +40,7 @@ const base64Encode = buffer => {
  * >查看定义:@see {@link Base64Encoder}
  * @constructor
  * @param {Object} options 流选项
- * @param {Number} [options.lineLength=76] 行最大长度，设置为false可禁用换行
+ * @param {Number} [options.lineLength=76] 行最大长度,设置为false可禁用换行
  */
 class Base64Encoder extends Transform {
     constructor(options = {}) {
@@ -54,16 +55,16 @@ class Base64Encoder extends Transform {
     }
 
     _transform(chunk, encoding, done) {
-        if (encoding !== 'buffer') chunk = Buffer.from(chunk, encoding); // 如果不是Buffer，则按指定编码转换为Buffer
-        if (!chunk?.length) return setImmediate(done);                   // 如果没有数据，直接返回
+        if (encoding !== 'buffer') chunk = Buffer.from(chunk, encoding); // 如果不是Buffer,则按指定编码转换为Buffer
+        if (!chunk?.length) return setImmediate(done);                   // 如果没有数据,直接返回
 
         this.inputBytes += chunk.length;
-        // 如果上次有剩余的字节，先补齐
+        // 如果上次有剩余的字节,先补齐
         const rLen = this._remainingBytes?.length ?? 0;
         if (rLen)
             chunk = Buffer.concat([this._remainingBytes, chunk], rLen + chunk.length), this._remainingBytes = false;
 
-        // base64每3个字节编码为4个字符，如果不是3的倍数，则剩余的字节留到下次处理
+        // base64每3个字节编码为4个字符,如果不是3的倍数,则剩余的字节留到下次处理
         const remain = chunk.length % 3;
         if (remain) {
             const chunkEnd = chunk.length - remain;

package/lib/dkim/index.js

@@ -1,5 +1,5 @@
 /**
- * 用于邮件服务器或邮件发送系统,为外发邮件添加DKIM签名，
+ * 用于邮件服务器或邮件发送系统,为外发邮件添加DKIM签名,
  * 提高邮件的可信度和防伪造能力,帮助通过SPF、DKIM、DMARC等反垃圾邮件验证
  */
 import { unlink, createReadStream, createWriteStream } from 'fs';
@@ -64,7 +64,7 @@ class DKIMSigner {
 
         // 如果没有缓存文件则结束输出,否则创建读取缓存流
         if (this.readPos >= this.chunks.length) return !this.cache ? this.output.end() : this.createReadCache();
-        // 写入数据，如果返回false则等待'drain'事件
+        // 写入数据,如果返回false则等待'drain'事件
         const chunk = this.chunks[this.readPos++];
         if (this.output.write(chunk) === false) return this.output.once('drain', () => this.sendNextChunk());
         setImmediate(() => this.sendNextChunk());
@@ -74,12 +74,13 @@ class DKIMSigner {
     sendSignedOutput() {
         let keyPos = 0;
         const signNextKey = () => {
-            // 所有密钥都已处理，发送原始头部并继续发送数据块
+            // 所有密钥都已处理,发送原始头部并继续发送数据块
             if (keyPos >= this.keys.length) {
                 this.output.write(this.parser.rawHeaders);
                 return setImmediate(() => this.sendNextChunk());
             }
-            const { domainName, keySelector, privateKey } = this.keys[keyPos++], { headerFieldNames, skipFields } = this.options,
+            const { domainName, keySelector, privateKey } = this.keys[keyPos++],
+                { headerFieldNames, skipFields } = this.options,
                 // 定义 DKIM 签名字段
                 dkimField = signer(this.headers, this.hashAlgo, this.bodyHash,
                     { domainName, keySelector, privateKey, headerFieldNames, skipFields });
@@ -145,22 +146,22 @@ class DKIMSigner {
  *   const dkim = new DKIM({
  *       domainName: 'example.com',        // 域名,用于标识签名来源
  *        keySelector: 'key-selector',     // 密钥选择器,用于在DNS中查找公钥
- *        privateKey, // RSA 私钥,PEM 格式字符串（包含 -----BEGIN RSA PRIVATE KEY----- 等）,用于生成 DKIM 签名
+ *        privateKey, // RSA 私钥,PEM 格式字符串(包含 -----BEGIN RSA PRIVATE KEY----- 等),用于生成 DKIM 签名
  *        cacheDir: '/tmp'                 // 缓存目录,用于处理大邮件时的临时存储
  *    });
  *
  *    // 2. 对邮件进行签名
  *    dkim.sign(input).pipe(process.stdout);
  * ```
- *  参数说明：
- *    input: 输入邮件内容，可以是以下类型：
- *    Stream (流)：可读流，包含RFC822格式的原始邮件
- *    String (字符串)：邮件内容的字符串形式
- *    Buffer (缓冲区)：邮件内容的二进制缓冲区
+ *  参数说明:
+ *    input: 输入邮件内容,可以是以下类型:
+ *    Stream (流):可读流,包含RFC822格式的原始邮件
+ *    String (字符串):邮件内容的字符串形式
+ *    Buffer (缓冲区):邮件内容的二进制缓冲区
  *
- *  - 返回值：一个可读流，包含已添加DKIM签名的完整邮件
+ *  - 返回值:一个可读流,包含已添加DKIM签名的完整邮件
  *
- *  工作流程：
+ *  工作流程:
  *  1. 解析输入邮件的头部和正文
  *  2. 对邮件正文进行规范化处理并计算哈希值
  *  3. 使用私钥对指定邮件头字段和正文哈希进行签名
@@ -180,14 +181,14 @@ class DKIM {
         const output = new PassThrough();
         let inputStream = input, writeValue = false;
 
-        // 如果输入是字符串或Buffer，则转换为流
+        // 如果输入是字符串或Buffer,则转换为流
         if (Buffer.isBuffer(input)) writeValue = input, inputStream = new PassThrough();
-        // 否则如果输入是字符串，则转换为Buffer
+        // 否则如果输入是字符串,则转换为Buffer
         else if (typeof input === 'string') writeValue = Buffer.from(input), inputStream = new PassThrough();
 
         const options = this.options;
         let newOptions = {};
-        // 如果有额外选项，则合并选项
+        // 如果有额外选项,则合并选项
         if (extraOptions && Object.keys(extraOptions).length) {
             newOptions = { ...options };
             // 仅添加不存在的选项
@@ -197,11 +198,13 @@ class DKIM {
         }
         else newOptions = options;
 
-        const signer = new DKIMSigner(newOptions, this.keys, inputStream, output); // 创建 DKIM 签名器实例,使用最终的合并选项
+// 创建 DKIM 签名器实例,使用最终的合并选项
+        const signer = new DKIMSigner(newOptions, this.keys, inputStream, output);
         // 异步启动签名流处理
         setImmediate(() => {
             signer.signStream();
-            if (writeValue) setImmediate(() => inputStream.end(writeValue));       // 如果有写入值,则在下一个事件循环中结束输入流
+// 如果有写入值,则在下一个事件循环中结束输入流
+            if (writeValue) setImmediate(() => inputStream.end(writeValue));      
         });
 
         return output;

package/lib/dkim/message-parser.js

@@ -29,7 +29,7 @@ class MessageParser extends Transform {
 
     // 在流结束时处理任何剩余的头信息
     _flush(callback) {
-        // 如果还有未处理的头信息块，则推送它们
+        // 如果还有未处理的头信息块,则推送它们
         if (this.headerChunks) {
             const chunk = Buffer.concat(this.headerChunks, this.headerBytes);
             this.bodySize += chunk.length, this.push(chunk), this.headerChunks = null;
@@ -38,7 +38,7 @@ class MessageParser extends Transform {
     }
 
     /**
-     * 更新记录最后4个字节，以便在块边界检测换行符
+     * 更新记录最后4个字节,以便在块边界检测换行符
      *
      * @param {Buffer} data 来自流的下一个数据块
      */
@@ -52,27 +52,29 @@ class MessageParser extends Transform {
     }
 
     /**
-     * 从剩余的消息体中查找并移除消息头。将头信息保持分离，直到最终投递，以便修改
+     * 从剩余的消息体中查找并移除消息头;将头信息保持分离,直到最终投递,以便修改
      *
      * @param {Buffer} data 下一个数据块
-     * @return {Boolean} 如果已经找到头信息则返回true，否则返回false
+     * @return {Boolean} 如果已经找到头信息则返回true,否则返回false
      */
     checkHeaders(data) {
-        if (this.headersParsed) return true; // 如果已经找到头信息，则不需要检查
+        if (this.headersParsed) return true; // 如果已经找到头信息,则不需要检查
 
         const lblen = this.lastBytes.length;
         let headerPos = 0;
         this.curLinePos = 0;
-        // 检查是否有两个连续的换行符，表示头信息的结尾
+        // 检查是否有两个连续的换行符,表示头信息的结尾
         for (let i = 0; i < lblen + data.length; i++) {
-            const chr = i < lblen ? this.lastBytes[i] : data[i - lblen]; // 如果小于长度,使用lastBytes中的字节,否则使用data中的字节
+// 如果小于长度,使用lastBytes中的字节,否则使用data中的字节
+            const chr = i < lblen ? this.lastBytes[i] : data[i - lblen];
             // 检查是否有两个连续的换行符
             if (chr === 0x0a && i) {
-                const pr1 = i - 1 < lblen ? this.lastBytes[i - 1] : data[i - 1 - lblen], // 定义pr1为当前字节的前一个字节的值
+// 定义pr1为当前字节的前一个字节的值
+                const pr1 = i - 1 < lblen ? this.lastBytes[i - 1] : data[i - 1 - lblen],
                     // 定义pr2为当前字节的前两个字节的值(如果存在)
                     pr2 = i > 1 ? (i - 2 < lblen ? this.lastBytes[i - 2] : data[i - 2 - lblen]) : false;
 
-                // 如果前一个字符是0x0a，或者前两个字符是0x0d 0x0a，则表示头信息结束
+                // 如果前一个字符是0x0a,或者前两个字符是0x0d 0x0a,则表示头信息结束
                 if (pr1 === 0x0a || (pr1 === 0x0d && pr2 === 0x0a)) {
                     this.headersParsed = true, headerPos = i - lblen + 1, this.headerBytes += headerPos;
                     break;
@@ -82,9 +84,10 @@ class MessageParser extends Transform {
 
         // 如果找到了头信息
         if (this.headersParsed) {
-            this.headerChunks.push(data.subarray(0, headerPos)), this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
+            this.headerChunks.push(data.subarray(0, headerPos)),
+                this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
             this.headerChunks = null, this.emit('headers', this.parseHeaders());
-            // 如果数据块中还有剩余的消息体，则推送剩余的消息体
+            // 如果数据块中还有剩余的消息体,则推送剩余的消息体
             if (data.length - 1 > headerPos) {
                 const chunk = data.subarray(headerPos);
                 this.bodySize += chunk.length, setImmediate(() => this.push(chunk));
@@ -103,7 +106,7 @@ class MessageParser extends Transform {
         const lines = (this.rawHeaders || '').toString().split(regexs.LINE_SEPARATOR); // 按行拆分(丢弃换行符)
         // 处理折叠的头信息行
         for (let i = lines.length - 1; i > 0; i--)
-            // 如果当前行是空白行，则将其与前一行合并
+            // 如果当前行是空白行,则将其与前一行合并
             if (regexs.FOLDED_HEADER_LINE.test(lines[i])) lines[i - 1] += `\n${lines[i]}`, lines.splice(i, 1);
 
         return lines.filter(line => line.trim())

package/lib/dkim/relaxed-body.js

@@ -4,7 +4,7 @@ import { regexs, resetRegex } from '../regexs.js';
 
 /**
  * 宽松规范化邮件正文的转换流,实现DKIM签名中的relaxed body canonicalization
- * - 主要功能：
+ * - 主要功能:
  * 1. 将所有的行结束符统一为CRLF
  * 2. 移除每行末尾的空白字符(WSP)
  * 3. 将行内的多个空白字符替换为单个空格
@@ -15,7 +15,7 @@ class RelaxedBody extends Transform {
     /**
      * 构造函数
      * @param {Object} options - 配置选项
-     * @param {string} options.hashAlgo - 哈希算法，默认为'sha1'
+     * @param {string} options.hashAlgo - 哈希算法,默认为'sha1'
      * @param {boolean} options.debug - 是否启用调试模式
      */
     constructor(options = {}) {
@@ -28,7 +28,7 @@ class RelaxedBody extends Transform {
 
     /**
      * 处理数据块并更新哈希值
-     * 应用宽松规范化规则：
+     * 应用宽松规范化规则:
      * 1. 将所有行结束符统一为CRLF
      * 2. 移除行尾空白字符(WSP)
      * 3. 将行内多个空白字符替换为单个空格
@@ -37,15 +37,16 @@ class RelaxedBody extends Transform {
     updateHash(chunk) {
         // 将当前数据块转换为字符串并与之前的余数合并
         const fullStr = this.remainder + chunk.toString('latin1');
-        if (fullStr.length === 0) return;                       // 如果合并后字符串为空，无需处理
-        this.remainder = '';                                    // 清空余数，将在处理过程中重新收集
-        const lines = fullStr.split(regexs.SPLIT_KEEP_NEWLINE); // 使用正则表达式按行分割，保留行结束符信息
-        if (!regexs.TRAILING_LINE_BREAK.test(fullStr)) this.remainder = lines.pop() || ''; // 如最后不是完整的行结束符,保留作为余数
+        if (fullStr.length === 0) return;                       // 如果合并后字符串为空,无需处理
+        this.remainder = '';                                    // 清空余数,将在处理过程中重新收集
+        const lines = fullStr.split(regexs.SPLIT_KEEP_NEWLINE); // 使用正则表达式按行分割,保留行结束符信息
+// 如最后不是完整的行结束符,保留作为余数
+        if (!regexs.TRAILING_LINE_BREAK.test(fullStr)) this.remainder = lines.pop() || '';
 
-        // 处理每一行内容（跳过行结束符部分）
+        // 处理每一行内容(跳过行结束符部分)
         const processedLines = [];
         for (let i = 0; i < lines.length; i++) {
-            // 如果是行结束符，直接添加
+            // 如果是行结束符,直接添加
             if (i % 2 === 1) {
                 processedLines.push(lines[i]);
                 continue;
@@ -61,9 +62,9 @@ class RelaxedBody extends Transform {
 
         // 重新组装处理后的内容
         let processedStr = processedLines.join('');
-        // 如果有余数，需要特殊处理（可能是不完整的行）
+        // 如果有余数,需要特殊处理(可能是不完整的行)
         if (this.remainder) {
-            // 余数中的空白字符处理（但不移除行尾空白，因为可能不是完整行）
+            // 余数中的空白字符处理(但不移除行尾空白,因为可能不是完整行)
             const rMW = resetRegex(regexs.MULTIPLE_WSP), pRemainder = this.remainder.replace(rMW, ' ');
             processedStr += pRemainder;
         }
@@ -75,14 +76,14 @@ class RelaxedBody extends Transform {
     }
 
     /**
-     * 转换流的核心方法，处理输入数据
+     * 转换流的核心方法,处理输入数据
      * @param {Buffer|string} chunk - 输入数据块
      * @param {string} encoding - 编码方式
      * @param {function} callback - 完成回调
      */
     _transform(chunk, encoding, callback) {
         try {
-            // 如果是空块，更新哈希并完成
+            // 如果是空块,更新哈希并完成
             if (!chunk?.length) {
                 this.updateHash(Buffer.alloc(0));
                 return callback();
@@ -110,12 +111,12 @@ class RelaxedBody extends Transform {
                     pRemainder = this.remainder.replace(regexs.TRAILING_WSP, '').replace(rMW, ' '),
                     remainderChunk = Buffer.from(pRemainder, 'latin1');
 
-                if (this.debug) this._debugBody.push(remainderChunk); // 调试模式：记录处理后的余数
+                if (this.debug) this._debugBody.push(remainderChunk); // 调试模式:记录处理后的余数
                 // 更新哈希值,将处理后的余数推送到输出流,然后更新已处理的字节长
                 this.bodyHash.update(remainderChunk); this.push(remainderChunk); this.byteLength += remainderChunk.length;
             }
 
-            // 确保以CRLF结束（如果消息体为空，或者余数不以CRLF结束）
+            // 确保以CRLF结束(如果消息体为空,或者余数不以CRLF结束)
             if (this.byteLength === 0 || !this.remainder?.endsWith('\r\n')) {
                 const crlf = Buffer.from('\r\n');
                 this.bodyHash.update(crlf), this.push(crlf);

package/lib/dkim/sign.js

@@ -1,11 +1,11 @@
 // 引入必要的模块
-import { createSign } from 'crypto';                // Node.js加密模块，用于生成签名
+import { createSign } from 'crypto';                // Node.js加密模块,用于生成签名
 import { toASCII } from '../punycode.js';           // 用于处理Unicode域名的punycode转换
 import { foldLines } from '../mime-funcs/index.js'; // 提供MIME相关工具函数
 import { regexs, resetRegex } from '../regexs.js';
 
 /**
- * 生成DKIM签名头（不含签名值部分）
+ * 生成DKIM签名头(不含签名值部分)
  *
  * @param {String} domainName 域名
  * @param {String} keySelector 密钥选择器
@@ -19,8 +19,8 @@ const _generateDKIMHeader = (domainName, keySelector, fieldNames, hashAlgo, body
     let dkim = [
         'v=1',                      // 版本
         `a=rsa-${hashAlgo}`,        // 算法
-        'c=relaxed/relaxed',        // 规范化方法（头/正文）
-        `d=${toASCII(domainName)}`, // 域名（转换为ASCII）
+        'c=relaxed/relaxed',        // 规范化方法(头/正文)
+        `d=${toASCII(domainName)}`, // 域名(转换为ASCII)
         'q=dns/txt',                // 查询方式
         `s=${keySelector}`,         // 密钥选择器
         `bh=${bodyHash}`,           // 正文哈希
@@ -34,8 +34,8 @@ const _generateDKIMHeader = (domainName, keySelector, fieldNames, hashAlgo, body
      * 从邮件头中提取并规范化指定字段的数据
      *
      * @param {Array} headers 邮件头数组
-     * @param {String} fieldNames 需要处理的字段列表（冒号分隔）
-     * @param {String} skipFields 需要跳过的字段列表（冒号分隔）
+     * @param {String} fieldNames 需要处理的字段列表(冒号分隔)
+     * @param {String} skipFields 需要跳过的字段列表(冒号分隔)
      * @return {Object} 包含规范化后的头数据和字段列表的对象
      */
     _relaxedHeaders = (headers, fieldNames = '', skipFields = '') => {
@@ -45,21 +45,21 @@ const _generateDKIMHeader = (domainName, keySelector, fieldNames, hashAlgo, body
         // 处理需要跳过的字段列表(去除空白并添加到跳过集合)
         skipFields.toLowerCase().split(':').forEach(field => skip.add(field.trim()));
 
-        // 处理需要包含的字段，过滤掉跳过的字段(添加到包含字段集合)
+        // 处理需要包含的字段,过滤掉跳过的字段(添加到包含字段集合)
         fieldNames.toLowerCase().split(':').filter(field => !skip.has(field.trim()))
             .forEach(field => includedFields.add(field.trim()));
 
-        // 从后向前遍历头（确保获取每个字段的最后出现值）
+        // 从后向前遍历头(确保获取每个字段的最后出现值)
         for (let i = headers.length - 1; i >= 0; i--) {
             const { key, line } = headers[i];
-            // 只包含第一个遇到的值（从底部到顶部）
+            // 只包含第一个遇到的值(从底部到顶部)
             if (includedFields.has(key) && !headerFields.has(key)) headerFields.set(key, _relaxedHeaderLine(line));
         }
 
         // 构建规范化后的头数据行和字段列表
         const headersList = [], fields = [];
         includedFields.forEach(field => {
-            // 如果字段在头中存在，则将其添加到规范化数据中
+            // 如果字段在头中存在,则将其添加到规范化数据中
             if (headerFields.has(field)) fields.push(field), headersList.push(`${field}:${headerFields.get(field)}`);
         });
 
@@ -103,12 +103,13 @@ const generateDKIMSignature = (headers, hashAlgo, bodyHash, options = {}) => {
         fieldNames = headerFieldNames || defaultFieldNames,            // 使用选项中的头字段列表或默认列表
         result = _relaxedHeaders(headers, fieldNames, skipFields),     // 获取经过"relaxed"规范化的头数据及字段列表
 
-        // 生成DKIM签名头（不包含签名值部分）
+        // 生成DKIM签名头(不包含签名值部分)
         dkimHeader = _generateDKIMHeader(domainName, keySelector, result.fieldNames, hashAlgo, bodyHash);
 
     let signer, signature;
-    result.headers += `dkim-signature:${_relaxedHeaderLine(dkimHeader)}`; // 将DKIM签名头自身添加到规范化数据中(用于生成签名)
-    // 创建签名对象，使用指定的哈希算法;更新要签名的数据（规范化后的头数据）
+// 将DKIM签名头自身添加到规范化数据中(用于生成签名)
+    result.headers += `dkim-signature:${_relaxedHeaderLine(dkimHeader)}`;
+    // 创建签名对象,使用指定的哈希算法;更新要签名的数据(规范化后的头数据)
     signer = createSign((`rsa-${hashAlgo}`).toUpperCase()), signer.update(result.headers);
     try {
         signature = signer.sign(privateKey, 'base64');                    // 使用私钥进行签名,输出Base64格式

package/lib/fetch/cookies.js

@@ -1,5 +1,5 @@
 // Cookie处理模块
-const SESSION_TIMEOUT = 1800; // 会话默认超时时间：30分钟（1800秒）
+const SESSION_TIMEOUT = 1800; // 会话默认超时时间:30分钟(1800秒)
 
 /**
  * 创建一个Biskviit Cookie存储容器,用于内存中的Cookie管理
@@ -15,14 +15,14 @@ class Cookies {
     // 检查主机名是否匹配Cookie域名
     #isDomainMatch(hostname, domain) {
         if (hostname === domain) return true; // 精确匹配
-        // 如果域名以点开头，则匹配所有子域名,否则返回false
+        // 如果域名以点开头,则匹配所有子域名,否则返回false
         return domain.startsWith('.') ? (`.${hostname}`).endsWith(domain) : false;
     }
 
     /**
      * 尝试将给定的字符串解析为URL对象
-     * @param {string} str - 需要解析的URL字符串，默认为空字符串
-     * @returns {URL|boolean} 如果解析成功返回URL对象，否则返回false
+     * @param {string} str - 需要解析的URL字符串,默认为空字符串
+     * @returns {URL|boolean} 如果解析成功返回URL对象,否则返回false
      */
     #newURL(str = '') {
         try {
@@ -45,21 +45,22 @@ class Cookies {
         const cookie = this.parse(cookieStr), // 解析Cookie字符串
             { hostname, pathname } = urlObj, { domain, path, expires } = cookie;
 
-        // 当域名不存在时或域名存在但不匹配时，直接使用主机名;否则当域名存在且匹配时，保留原始值
+        // 当域名不存在时或域名存在但不匹配时,直接使用主机名;否则当域名存在且匹配时,保留原始值
         cookie.domain = !domain || !this.#isDomainMatch(hostname, domain) ? hostname : domain;
 
-        if (!path) cookie.path = this.getPath(pathname);  // 如果没有设置路径，使用URL的路径
-        // 如果没有过期时间，使用会话超时时间
-        if (!expires) cookie.expires = new Date(Date.now() + Number(this.options.sessionTimeout ?? SESSION_TIMEOUT) * 1000);
+        if (!path) cookie.path = this.getPath(pathname);  // 如果没有设置路径,使用URL的路径
+        // 如果没有过期时间,使用会话超时时间
+        if (!expires) cookie.expires =
+            new Date(Date.now() + Number(this.options.sessionTimeout ?? SESSION_TIMEOUT) * 1000);
 
         return this.add(cookie); // 添加Cookie到存储
     }
 
     /**
-     * 获取适用于指定URL的Cookie字符串，用于'Cookie:'请求头
+     * 获取适用于指定URL的Cookie字符串,用于'Cookie:'请求头
      *
      * @param {String} url 要检查的URL
-     * @returns {String} Cookie头字符串，如果没有匹配则返回空字符串
+     * @returns {String} Cookie头字符串,如果没有匹配则返回空字符串
      */
     get(url) {
         // 将Cookie对象转换为name=value格式,用分号和空格连接所有Cookie
@@ -76,7 +77,7 @@ class Cookies {
         const result = [];
         let cookie;
 
-        // 倒序遍历Cookie数组（便于删除过期Cookie）
+        // 倒序遍历Cookie数组(便于删除过期Cookie)
         for (let i = this.cookies.length - 1; i >= 0; i--) {
             cookie = this.cookies[i];
 
@@ -118,11 +119,11 @@ class Cookies {
                         break;
                     case 'domain': // 域名
                         domain = value.toLowerCase();
-                        // 如果域名存在且没有前导点，则添加前导点
+                        // 如果域名存在且没有前导点,则添加前导点
                         if (domain.length && !domain.startsWith('.')) domain = `.${domain}`;
                         cookie.domain = domain;
                         break;
-                    case 'max-age': // 最大存活时间（秒）
+                    case 'max-age': // 最大存活时间(秒)
                         cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1000);
                         break;
                     case 'secure': // 安全标志
@@ -132,7 +133,7 @@ class Cookies {
                         cookie.httponly = true;
                         break;
                     default:
-                        // 如果没有匹配的属性，则默认处理Cookie的名称和值
+                        // 如果没有匹配的属性,则默认处理Cookie的名称和值
                         if (!cookie.name) cookie.name = key, cookie.value = value;
                 }
             });
@@ -153,22 +154,23 @@ class Cookies {
         if (!this.#isDomainMatch(urlObj.hostname, cookie.domain)) return false; // 检查主机名是否不匹配Cookie域名
 
         const path = this.getPath(urlObj.pathname);                             // 检查路径是否匹配
-        if (!path.startsWith(cookie.path)) return false;                        // 如果路径不以Cookie路径开头，则不匹配
-        return cookie.secure && urlObj.protocol !== 'https:' ? false : true; // 如果Cookie是安全的但URL不是https，则不匹配,否则匹配
+        if (!path.startsWith(cookie.path)) return false;                        // 如果路径不以Cookie路径开头,则不匹配
+// 如果Cookie是安全的但URL不是https,则不匹配,否则匹配
+        return cookie.secure && urlObj.protocol !== 'https:' ? false : true;
     }
 
     /**
-     * 添加（或更新/删除）Cookie对象到Cookie存储
+     * 添加(或更新/删除)Cookie对象到Cookie存储
      *
      * @param {Object} cookie 要存储的Cookie值
      */
     add(cookie) {
         if (!cookie || !cookie.name) return false; // 如果Cookie无效则直接返回
 
-        // 检查是否有相同参数的Cookie（用于更新）
+        // 检查是否有相同参数的Cookie(用于更新)
         for (let i = 0; i < this.cookies.length; i++) {
             if (this.compare(this.cookies[i], cookie)) {
-                // 检查是否需要删除Cookie（如果已过期）
+                // 检查是否需要删除Cookie(如果已过期)
                 if (this.isExpired(cookie)) {
                     this.cookies.splice(i, 1);
                     return false;
@@ -179,7 +181,7 @@ class Cookies {
             }
         }
 
-        if (!this.isExpired(cookie)) this.cookies.push(cookie); // 如果没有过期，则添加为新Cookie
+        if (!this.isExpired(cookie)) this.cookies.push(cookie); // 如果没有过期,则添加为新Cookie
         return true;
     }
 
@@ -211,9 +213,9 @@ class Cookies {
      * @returns {String} 规范化后的路径
      */
     getPath(pathname) {
-        let path = pathname || '/'; // 处理空值，默认为根路径
+        let path = pathname || '/'; // 处理空值,默认为根路径
 
-        // 直接找到最后一个斜杠的位置，保留到该位置（包含斜杠）
+        // 直接找到最后一个斜杠的位置,保留到该位置(包含斜杠)
         const lastIndex = path.lastIndexOf('/');
         path = path.substring(0, lastIndex + 1);