@flun/mailer 2.1.24 → 2.1.25

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);
 

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) {