@flun/mailer 2.1.23 → 2.1.25

package/lib/mailer/mail-message.js

@@ -11,7 +11,7 @@ import { detectExtension, detectMimeType, isPlainText, encodeWord } from '../mim
  *  通常由 Mailer 实例内部创建和调用,不建议直接实例化;
  */
 class MailMessage {
-    // 构造函数，初始化邮件消息对象
+    // 构造函数,初始化邮件消息对象
     constructor(mailer, data = {}) {
         this.mailer = mailer, this.message = null;
         const { options = {}, _defaults = {} } = mailer;
@@ -22,37 +22,39 @@ class MailMessage {
         const headers = { ...defaults.headers, ...data.headers }, mailData = { ...defaults, ...data, headers };
         // 强制应用 transporter 选项中的特定键
         ['disableFileAccess', 'disableUrlAccess', 'normalizeHeaderKey'].forEach(key => {
-            if (key in options) mailData[key] = options[key]; // 如果在选项中设置，则使用选项值
+            if (key in options) mailData[key] = options[key]; // 如果在选项中设置,则使用选项值
         });
 
         return mailData;
     }
 
-    // 解析内容方法（代理给 resolveContent）
+    // 解析内容方法(代理给 resolveContent)
     resolveContent(...args) {
         return resolveContent(...args);
     }
 
-    // 解析所有内容（文本、HTML、附件等）
+    // 解析所有内容(文本、HTML、附件等)
     resolveAll(callback) {
         // 定义需要解析的内容键
         const keys = [
-            [this.data, 'html'], [this.data, 'text'], [this.data, 'watchHtml'], [this.data, 'amp'], [this.data, 'icalEvent']
+            [this.data, 'html'], [this.data, 'text'], [this.data, 'watchHtml'], [this.data, 'amp'],
+                [this.data, 'icalEvent']
         ], { alternatives, attachments } = this.data;
-        alternatives?.forEach((_, i) => keys.push([alternatives, i])); // 如果有替代内容，则添加到键中
+        alternatives?.forEach((_, i) => keys.push([alternatives, i])); // 如果有替代内容,则添加到键中
 
         // 处理附件
         attachments?.forEach((attachment, i) => {
             const { filename, path, href = '', contentType } = attachment;
             let newFname = filename;
-            // 如果没有文件名，则从路径或href中提取，或使用默认名称
+            // 如果没有文件名,则从路径或href中提取,或使用默认名称
             if (!newFname) {
                 newFname = (path || href).split('/').pop().split('?').shift() || `attachment-${(i + 1)}`;
-                if (!newFname.includes('.')) newFname += `.${detectExtension(contentType)}`; // 如果没有扩展名，则根据内容类型添加
+// 如果没有扩展名,则根据内容类型添加
+                if (!newFname.includes('.')) newFname += `.${detectExtension(contentType)}`;
                 attachment.filename = newFname; // 设置回attachment对象
             }
 
-            // 如果没有内容类型，则根据文件名、路径或href检测
+            // 如果没有内容类型,则根据文件名、路径或href检测
             if (!contentType) attachment.contentType = detectMimeType(newFname || path || href || 'bin');
             keys.push([attachments, i]);
         });
@@ -63,16 +65,16 @@ class MailMessage {
         addressKeys.forEach(address => {
             let value;
             const rAddress = this.message.getHeader(address === 'replyTo' ? 'reply-to' : address);
-            // 如果已有消息，从消息头解析地址
+            // 如果已有消息,从消息头解析地址
             if (this.message) value = [].concat(mimeNode.parseAddresses(rAddress) || []);
-            // 否则如果数据中有，则直接从数据中解析
+            // 否则如果数据中有,则直接从数据中解析
             else if (this.data[address]) value = [].concat(mimeNode.parseAddresses(this.data[address]) || []);
 
-            if (value?.length) this.data[address] = value;            // 如果有值，则保存到数据中
-            else if (address in this.data) this.data[address] = null; // 否则如果数据中有地址字段，则删除地址字段
+            if (value?.length) this.data[address] = value;            // 如果有值,则保存到数据中
+            else if (address in this.data) this.data[address] = null; // 否则如果数据中有地址字段,则删除地址字段
         });
 
-        // 处理单值地址字段（from, sender）;如果数据中有地址，则保存为地址对象
+        // 处理单值地址字段(from, sender);如果数据中有地址,则保存为地址对象
         ['from', 'sender'].forEach(address => {
             if (this.data[address]) this.data[address] = this.data[address].shift();
         });
@@ -87,11 +89,12 @@ class MailMessage {
             if (!parent || !currentItem) return resolveNext();       // 跳过空值
             resolveContent(...args, (err, value) => {
                 if (err) return callback(err);
-                const node = { content: value };                     // 创建内容节点，保留原始数据的其他属性
+                const node = { content: value };                     // 创建内容节点,保留原始数据的其他属性
                 if (currentItem && typeof currentItem === 'object' && !Buffer.isBuffer(currentItem))
                     Object.keys(currentItem).forEach(key => {
-                        // 如果没有在节点中，则从原始数据中复制属性
-                        if (!(key in node) && !['content', 'path', 'href', 'raw'].includes(key)) node[key] = currentItem[key];
+                        // 如果没有在节点中,则从原始数据中复制属性
+                        if (!(key in node) &&
+                            !['content', 'path', 'href', 'raw'].includes(key)) node[key] = currentItem[key];
                     });
 
                 parent[key] = node, resolveNext(); // 更新数据为节点对象并继续解析下一个
@@ -103,15 +106,16 @@ class MailMessage {
 
     // 规范化邮件数据
     normalize(callback) {
-        const envelope = this.data.envelope || this.message.getEnvelope(), messageId = this.message.messageId(); // 获取信封信息
+// 获取信封信息
+        const envelope = this.data.envelope || this.message.getEnvelope(), messageId = this.message.messageId();
         // 首先解析所有内容
         this.resolveAll((err, data) => {
-            if (err) return callback(err); // 如果解析失败，返回错误
+            if (err) return callback(err); // 如果解析失败,返回错误
 
             data.envelope = envelope, data.messageId = messageId; // 设置信封和消息ID
             ['html', 'text', 'watchHtml', 'amp'].forEach(key => {
                 const content = data[key]?.content;
-                // 如果内容不是是字符串，则转换为字符串,否则直接使用，
+                // 如果内容不是是字符串,则转换为字符串,否则直接使用,
                 if (content) data[key] = Buffer.isBuffer(content) ? content.toString() : content;
             });
 
@@ -158,7 +162,7 @@ class MailMessage {
 
     // 设置邮件发送器头部
     setMailerHeader() {
-        if (!this.message || !this.data.xMailer) return;        // 如果没有消息或没有xMailer，则直接返回
+        if (!this.message || !this.data.xMailer) return;        // 如果没有消息或没有xMailer,则直接返回
         this.message.setHeader('X-Mailer', this.data.xMailer);
     }
 
@@ -177,7 +181,7 @@ class MailMessage {
     // 设置列表头部
     setListHeaders() {
         const list = this.data.list;
-        if (!this.message || !list || typeof list !== 'object') return; // 如果没有消息或没有列表头部，则直接返回
+        if (!this.message || !list || typeof list !== 'object') return; // 如果没有消息或没有列表头部,则直接返回
 
         // 添加可选的 List-* 头部
         if (list && typeof list === 'object')
@@ -206,7 +210,7 @@ class MailMessage {
                                     url = formattedUrl.replace(regexs.LIST_ID_PROTOCOL_REMOVE, '');
                                 return quotedComment + url; // List-ID: "comment" <domain>
                             }
-                            // 返回格式化后的URL和注释（List-*: <http://domain> (comment)）
+                            // 返回格式化后的URL和注释(List-*: <http://domain> (comment))
                             return comment ? `${formattedUrl} (${comment})` : formattedUrl;
                         }).join(', ')
                 }]
@@ -218,7 +222,7 @@ class MailMessage {
         const rUC = resetRegex(regexs.URL_CLEAN);
         url = url.replace(rUC, '');                               // 去除空白和尖括号
         if (regexs.PROTOCOL_CHECK.test(url)) return `<${url}>`;   // 如果包含协议，则使用尖括号包裹
-        // 如果包含@，则使用mailto协议,否则使用HTTP协议
+        // 如果包含@,则使用mailto协议,否则使用HTTP协议
         return regexs.EMAIL_CHECK.test(url) ? `<mailto:${url}>` : `<http://${url}>`;
     }
 }

package/lib/mime-funcs/index.js

@@ -45,8 +45,8 @@ const defaultMimeType = 'application/octet-stream', defaultExtension = 'bin',
     };
 
 /**
- * 检查值是否为纯文本字符串（仅使用可打印的7位字符）
- * 允许的控制字符：\x09（制表符）、\x0a（换行符）、\x0d（回车符）、可打印ASCII(\x20-\x7e)
+ * 检查值是否为纯文本字符串(仅使用可打印的7位字符)
+ * 允许的控制字符:\x09(制表符)、\x0a(换行符)、\x0d(回车符)、可打印ASCII(\x20-\x7e)
  * 排除: 其他控制字符和DEL,非ASCII字符
  * >查看定义:@see {@link isPlainText}
  * @param {String} value 要测试的字符串
@@ -54,16 +54,16 @@ const defaultMimeType = 'application/octet-stream', defaultExtension = 'bin',
  * @returns {Boolean} 如果是纯文本字符串则返回true
  */
 const isPlainText = (value, isParam) => {
-    // 如果是参数，则允许双引号，否则不允许
+    // 如果是参数,则允许双引号,否则不允许
     const re = isParam ? regexs.PARAM_PLAIN_TEXT : regexs.PLAIN_TEXT;
     return typeof value === 'string' && !re.test(value);
 },
 
     /**
-     * 拆分MIME编码的字符串。用于将MIME字分成更小的块
+     * 拆分MIME编码的字符串;用于将MIME字分成更小的块
      *
      * @param {String} str 要拆分的MIME编码字符串
-     * @param {Number} maxlen 一个部分的最大字符长度（最小12）
+     * @param {Number} maxlen 一个部分的最大字符长度(最小12)
      * @return {Array} 拆分后的字符串
      */
     _splitMimeEncodedString = (str = '', maxlen) => {
@@ -82,7 +82,7 @@ const isPlainText = (value, isParam) => {
                 // 检查是否不在Unicode字符序列的中间
                 if ((match = str.substring(curLine.length).match(regexs.ENCODED_SEQUENCE))) {
                     chr = parseInt(match[1], 16);
-                    // 无效序列，向后移动一个字符并重新检查
+                    // 无效序列,向后移动一个字符并重新检查
                     if (chr < 0xc2 && chr > 0x7f) curLine = curLine.substring(0, curLine.length - 3), done = false;
                 }
             }
@@ -95,8 +95,8 @@ const isPlainText = (value, isParam) => {
     },
 
     /**
-     * 将字符串或Buffer编码为UTF-8参数值连续编码（rfc2231）
-     * 用于拆分长参数值。
+     * 将字符串或Buffer编码为UTF-8参数值连续编码(rfc2231)
+     * 用于拆分长参数值;
      *
      * 例如
      *      title="unicode string"
@@ -121,19 +121,20 @@ const isPlainText = (value, isParam) => {
                 return '';
             });
 
-            if (encodedStr) list.push({ line: encodedStr }); // 如果最后一个字符串不为空，则将其推送到数组中
+            if (encodedStr) list.push({ line: encodedStr }); // 如果最后一个字符串不为空,则将其推送到数组中
         }
-        // 否则，如果字符串包含Unicode或特殊字符，则将其拆分为多个块
+        // 否则,如果字符串包含Unicode或特殊字符,则将其拆分为多个块
         else {
             let chr, i, len, line = "utf-8''", encoded = true, startPos = 0;
-            // 如果字符串包含代理对，则将其规范化为字符数组
+            // 如果字符串包含代理对,则将其规范化为字符数组
             if (regexs.UTF16_HIGH_SURROGATE.test(encodedStr)) {
                 const encodedStrArr = [];
                 for (i = 0, len = encodedStr.length; i < len; i++) {
                     chr = encodedStr.charAt(i);
                     const ord = chr.charCodeAt(0);
-                    // 如果字符是代理对的第一个字符，则将其与第二个字符一起添加到数组中
-                    if (ord >= 0xd800 && ord <= 0xdbff && i < len - 1) chr += encodedStr.charAt(i + 1), encodedStrArr.push(chr), i++;
+                    // 如果字符是代理对的第一个字符,则将其与第二个字符一起添加到数组中
+                    if (ord >= 0xd800 && ord <= 0xdbff && i < len - 1) chr += encodedStr.charAt(i + 1),
+                        encodedStrArr.push(chr), i++;
                     else encodedStrArr.push(chr); // 否则,将其添加到数组中
                 }
                 encodedStr = encodedStrArr
@@ -143,13 +144,13 @@ const isPlainText = (value, isParam) => {
             for (i = 0; i < encodedStr.length; i++) {
                 chr = encodedStr[i];
                 const encodedChr = _safeEncodeURIComponent(chr);
-                if (encoded) chr = encodedChr; // 如果需要编码，则对当前字符进行URL编码
+                if (encoded) chr = encodedChr; // 如果需要编码,则对当前字符进行URL编码
                 else {
                     chr = chr === ' ' ? chr : encodedChr; // 尝试对当前字符进行URL编码
-                    // 默认情况下不需要编码行，只有当字符串包含Unicode或特殊字符时才需要
+                    // 默认情况下不需要编码行,只有当字符串包含Unicode或特殊字符时才需要
                     if (chr !== encodedStr[i]) {
                         // 检查是否可以将编码字符添加到行中
-                        // 如果不能，则没有理由使用此行，只需将其推送到列表,并开始新行处理需要编码的字符
+                        // 如果不能,则没有理由使用此行,只需将其推送到列表,并开始新行处理需要编码的字符
                         if ((_safeEncodeURIComponent(line) + chr).length >= maxLength)
                             list.push({ line, encoded }), line = '', startPos = i - 1;
                         else {
@@ -159,25 +160,26 @@ const isPlainText = (value, isParam) => {
                     }
                 }
 
-                // 如果行已经太长，将其推送到列表并开始新行
+                // 如果行已经太长,将其推送到列表并开始新行
                 if ((line + chr).length >= maxLength) {
-                    list.push({ line, encoded }), line = chr = encodedStr[i] === ' ' ? ' ' : _safeEncodeURIComponent(encodedStr[i]);
-                    // 如果添加的字符不需要编码，则将编码设置为false,并继续处理下一个字符;否则设为需要编码
+                    list.push({ line, encoded }),
+                        line = chr = encodedStr[i] === ' ' ? ' ' : _safeEncodeURIComponent(encodedStr[i]);
+                    // 如果添加的字符不需要编码,则将编码设置为false,并继续处理下一个字符;否则设为需要编码
                     chr === encodedStr[i] ? (encoded = false, startPos = i - 1) : encoded = true;
                 }
-                else line += chr;                   // 否则，将字符添加到行中
+                else line += chr;                   // 否则,将字符添加到行中
             }
 
-            if (line) list.push({ line, encoded }); // 如果最后一行不为空，则将其推送到列表中
+            if (line) list.push({ line, encoded }); // 如果最后一行不为空,则将其推送到列表中
         }
 
-        // 如果任何行需要编码，则第一行（part==0）总是编码的
+        // 如果任何行需要编码,则第一行(part==0)总是编码的
         return list.map((item, i) => ({ key: `${key}*${i}${(item.encoded ? '*' : '')}`, value: item.line }));
     },
 
     /**
      * 处理 RFC2231 编码的参数
-     * 将拆分的rfc2231字符串合并到单个键中，并进行解码
+     * 将拆分的rfc2231字符串合并到单个键中,并进行解码
      * @param {Object} params 参数对象
      */
     _processRFC2231Params = params => {
@@ -186,7 +188,8 @@ const isPlainText = (value, isParam) => {
             let match, value;
             if ((match = key.match(regexs.RFC2231_KEY))) {
                 const actualKey = key.substring(0, match.index), nr = Number(match[2] || match[3]) || 0;
-                if (!params[actualKey] || typeof params[actualKey] !== 'object') params[actualKey] = { charset: false, values: [] };
+                if (!params[actualKey] || typeof params[actualKey] !== 'object')
+                    params[actualKey] = { charset: false, values: [] };
 
                 value = params[key];
                 if (nr === 0 && match[0].endsWith('*') && (match = value.match(regexs.CHARSET_LANGUAGE_VALUE)))
@@ -217,7 +220,7 @@ const isPlainText = (value, isParam) => {
 
 /**
  * 检查多行字符串是否包含超过指定长度的行
- * 如果值是纯文本但有超过允许长度的行，则使用format=flowed
+ * 如果值是纯文本但有超过允许长度的行,则使用format=flowed
  * >查看定义:@see {@link hasLongerLines}
  * @param {String} str 要检查的字符串(不检查超过128kB的字符串)
  * @param {Number} lineLength 要检查的最大行长度
@@ -231,8 +234,8 @@ const hasLongerLines = (str, lineLength) => {
  * 将字符串或Buffer编码为UTF-8 MIME字(rfc2047)
  * >查看定义:@see {@link encodeWord}
  * @param {String|Buffer} data 要编码的字符串
- * @param {String} mimeWordEncoding='Q' MIME字的编码，Q或B
- * @param {Number} [maxLength=0] 如果设置，根据需要将MIME字拆分为多个块
+ * @param {String} mimeWordEncoding='Q' MIME字的编码,Q或B
+ * @param {Number} [maxLength=0] 如果设置,根据需要将MIME字拆分为多个块
  * @return {String} 单个或多个连接在一起的MIME字
  */
 const encodeWord = (data, mimeWordEncoding = "Q", maxLength = 0) => {
@@ -242,15 +245,15 @@ const encodeWord = (data, mimeWordEncoding = "Q", maxLength = 0) => {
     const toCharset = 'UTF-8', offset = 7 + toCharset.length;
     maxLength && maxLength > offset && (maxLength -= offset);
 
-    // 如果mimeWordEncoding为Q，则使用qp编码，否则使用base64编码
+    // 如果mimeWordEncoding为Q,则使用qp编码,否则使用base64编码
     if (newMWE === 'Q') {
         const rNSC = resetRegex(regexs.NON_SAFE_CHAR);
         encodedStr = qpEncode(data).replace(rNSC, chr => {
             const ord = chr.charCodeAt(0).toString(16).toUpperCase(), XX = ord.length === 1 ? `0${ord}` : ord
-            return chr === ' ' ? '_' : `=${XX}`;// 如果字符是空格，则使用_;否则使用=XX
+            return chr === ' ' ? '_' : `=${XX}`;// 如果字符是空格,则使用_;否则使用=XX
         });
     }
-    // 否则如果mimeWordEncoding为B，则使用base64编码
+    // 否则如果mimeWordEncoding为B,则使用base64编码
     else if (newMWE === 'B') {
         encodedStr = typeof data === 'string' ? data : base64Encode(data);
         maxLength = maxLength ? Math.max(3, ((maxLength - (maxLength % 4)) / 4) * 3) : 0;
@@ -264,16 +267,16 @@ const encodeWord = (data, mimeWordEncoding = "Q", maxLength = 0) => {
             let lpart = '';
             for (let i = 0, len = encodedStr.length; i < len; i++) {
                 let chr = encodedStr.charAt(i);
-                // 如果字符是emoji，则将下一个字符也添加到字符串中
+                // 如果字符是emoji,则将下一个字符也添加到字符串中
                 if (regexs.EMOJI_OR_SURROGATE.test(chr) && i < len - 1) chr += encodedStr.charAt(++i);
 
-                // 如果字符串加上当前字符的长度超过最大长度，则将字符串推送到数组中，并开始一个新的字符串
+                // 如果字符串加上当前字符的长度超过最大长度,则将字符串推送到数组中,并开始一个新的字符串
                 if (Buffer.byteLength(lpart + chr) <= maxLength || i === 0) lpart += chr;
-                else parts.push(base64Encode(lpart)), lpart = chr;  // 达到长度限制，推送现有字符串并重新开始
+                else parts.push(base64Encode(lpart)), lpart = chr;  // 达到长度限制,推送现有字符串并重新开始
             }
-            if (lpart) parts.push(base64Encode(lpart));             // 如果最后一个字符串不为空，则将其推送到数组中
+            if (lpart) parts.push(base64Encode(lpart));             // 如果最后一个字符串不为空,则将其推送到数组中
 
-            // 如果有多个字符串，则将它们连接到一起，并用分隔符分隔;否则，如果只有一个字符串，则将其返回
+            // 如果有多个字符串,则将它们连接到一起,并用分隔符分隔;否则,如果只有一个字符串,则将其返回
             encodedStr = parts.length > 1 ? parts.join(delimiter) : parts.join('');
         }
     }
@@ -285,20 +288,21 @@ const encodeWord = (data, mimeWordEncoding = "Q", maxLength = 0) => {
  * 查找包含非ASCII文本的单词序列并将其转换为MIME字
  * >查看定义:@see {@link encodeWords}
  * @param {String} value 要编码的字符串
- * @param {String} mimeWordEncoding='Q' MIME字的编码，Q或B
- * @param {Number} [maxLength=0] 如果设置，根据需要将MIME字拆分为多个块
- * @param {Boolean} [encodeAll=false] 如果为true且值需要编码，则编码整个字符串，而不仅仅是最小匹配
+ * @param {String} mimeWordEncoding='Q' MIME字的编码,Q或B
+ * @param {Number} [maxLength=0] 如果设置,根据需要将MIME字拆分为多个块
+ * @param {Boolean} [encodeAll=false] 如果为true且值需要编码,则编码整个字符串,而不仅仅是最小匹配
  * @return {String} 可能包含MIME字的字符串
  */
 const encodeWords = (value, mimeWordEncoding = "Q", maxLength = 0, encodeAll) => {
-    // 查找第一个和最后一个是否包含不可打印ASCII或特殊符号的单词,如果找不到，则返回原始值
+    // 查找第一个和最后一个是否包含不可打印ASCII或特殊符号的单词,如果找不到,则返回原始值
     const firstMatch = value.match(regexs.FIRST_NON_ASCII_WORD), lastMatch = value.match(regexs.LAST_NON_ASCII_WORD);
     if (!firstMatch || !lastMatch) return value;
-    // 如果请求编码所有内容或字符串包含类似编码字的内容，则返回编码后的所有内容
+    // 如果请求编码所有内容或字符串包含类似编码字的内容,则返回编码后的所有内容
     if (encodeAll) return encodeWord(value, mimeWordEncoding, maxLength);
 
     const startIndex = firstMatch.index + firstMatch[0].length - firstMatch[0].trimStart().length,
-        endIndex = lastMatch.index + (lastMatch[1] || '').length, startStr = startIndex ? value.substring(0, startIndex) : '',
+        endIndex = lastMatch.index + (lastMatch[1] || '').length,
+            startStr = startIndex ? value.substring(0, startIndex) : '',
         endStr = endIndex < value.length ? value.substring(endIndex) : '',
         eWord = encodeWords(value.substring(startIndex, endIndex), mimeWordEncoding, maxLength);
     return `${startStr}${eWord}${endStr}`;
@@ -307,8 +311,8 @@ const encodeWords = (value, mimeWordEncoding = "Q", maxLength = 0, encodeAll) =>
 /**
  * 将解析后的头值连接为 'value; param1=value1; param2=value2';
  * >查看定义:@see {@link buildHeaderValue}
- * - 注意：我们遵循RFC 822来维护需要放在引号中的特殊字符列表;
- *       参考：https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
+ * - 注意:我们遵循RFC 822来维护需要放在引号中的特殊字符列表;
+ *       参考:https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
  * @param {Object} structured 解析后的头值
  * @return {String} 连接后的头值
  */
@@ -316,7 +320,7 @@ const buildHeaderValue = structured => {
     const paramsArray = [];
     Object.keys(structured.params || {}).forEach(param => {
         const pValue = structured.params[param];
-        // 如果值是纯文本字符串，则将其编码为MIME字
+        // 如果值是纯文本字符串,则将其编码为MIME字
         if (!isPlainText(pValue, true) || pValue.length >= 75) {
             _buildHeaderParam(param, pValue, 50).forEach(encodedParam => {
                 const { key, value } = encodedParam;
@@ -325,7 +329,7 @@ const buildHeaderValue = structured => {
                 else paramsArray.push(`${key}=${JSON.stringify(value)}`); // 否则将参数编码为JSON字符串
             });
         }
-        // 否则如果值是纯文本字符串，则将其编码为JSON字符串
+        // 否则如果值是纯文本字符串,则将其编码为JSON字符串
         else if (regexs.UNSAFE_PARAM_VALUE.test(pValue)) paramsArray.push(`${param}=${JSON.stringify(pValue)}`);
         else paramsArray.push(`${param}=${pValue}`);                    // 否则,如果值是安全的,则将其编码为MIME字
     });
@@ -346,7 +350,7 @@ const buildHeaderValue = structured => {
  */
 const parseHeaderValue = str => {
     const result = { value: '', params: {} };
-    if (!str || typeof str !== 'string') return result;  // 输入验证：如果输入为空或不是字符串，直接返回空结果
+    if (!str || typeof str !== 'string') return result;  // 输入验证:如果输入为空或不是字符串,直接返回空结果
 
     // 当前解析状态,正在解析的参数键名,正在解析的值,引号字符,是否处于转义状态
     let state = 'value', currentKey = '', currentValue = '', quoteChar = '', escaped = false;
@@ -354,7 +358,7 @@ const parseHeaderValue = str => {
     for (let i = 0; i < str.length; i++) {
         const char = str[i];
 
-        // 处理转义字符：如果前一个字符是\，当前字符直接加入值，不进行特殊处理
+        // 处理转义字符:如果前一个字符是\,当前字符直接加入值,不进行特殊处理
         if (escaped) {
             currentValue += char, escaped = false;
             continue;
@@ -362,16 +366,16 @@ const parseHeaderValue = str => {
 
         // 根据当前状态处理字符
         switch (state) {
-            case 'value':  // 解析主值部分（如：text/plain）
-                // 如果遇到分号，保存主值(去除前后空格),重置当前值,切换到键解析状态
+            case 'value':  // 解析主值部分(如:text/plain)
+                // 如果遇到分号,保存主值(去除前后空格),重置当前值,切换到键解析状态
                 if (char === ';') result.value = currentValue.trim(), currentValue = '', state = 'key';
                 else if (char === '\\') escaped = true;  // 遇到反斜杠设置转义为真
-                else currentValue += char;               // 普通字符：直接添加到当前值
+                else currentValue += char;               // 普通字符:直接添加到当前值
                 break;
-            case 'key':  // 解析参数键名（如：charset）
+            case 'key':  // 解析参数键名(如:charset)
                 if (char === '=') currentKey = currentValue.trim().toLowerCase(), currentValue = '', state = 'value';
                 else if (char === ';') {
-                    // 遇到分号但没有等号如：;flag
+                    // 遇到分号但没有等号如:;flag
                     if (currentValue.trim()) result.params[currentValue.trim().toLowerCase()] = '';  // 保存空值参数
                     currentValue = '';
                 }
@@ -384,11 +388,11 @@ const parseHeaderValue = str => {
                 break;
         }
 
-        // 检查是否需要进入引号状态（不在转义状态下）
+        // 检查是否需要进入引号状态(不在转义状态下)
         if (!escaped && (char === '"' || char === "'") && state !== 'quoted') quoteChar = char, state = 'quoted';
     }
 
-    const finalValue = currentValue.trim();                           // 循环结束后，处理最后剩余的值
+    const finalValue = currentValue.trim();                           // 循环结束后,处理最后剩余的值
     // 如果最后为值状态且有值
     if (state === 'value' && finalValue) {
         if (!result.value && !currentKey) result.value = finalValue;  // 如果主值还未设置且没有当前键,设置为主值
@@ -397,7 +401,7 @@ const parseHeaderValue = str => {
     // 否则,如果最后在为键状态且有值,设置为空参数
     else if (state === 'key' && finalValue) result.params[finalValue.toLowerCase()] = '';
 
-    _processRFC2231Params(result.params); // 处理 RFC2231 编码的参数（用于邮件头编码）
+    _processRFC2231Params(result.params); // 处理 RFC2231 编码的参数(用于邮件头编码)
     return result;
 };
 
@@ -408,15 +412,16 @@ const parseHeaderValue = str => {
  * @returns {string} 检测到的文件扩展名
  */
 const detectExtension = (mimeType = '') => {
-    // 如果MIME类型为空，返回默认扩展名
+    // 如果MIME类型为空,返回默认扩展名
     if (!mimeType) return defaultExtension;
 
-    // 处理MIME类型字符串:转换为小写,去除空格,按斜杠分割;获取主类型(如：application、text等)和子类型(处理包含斜杠的情况)
-    const parts = mimeType.toLowerCase().trim().split('/'), rootType = parts.shift().trim(), subType = parts.join('/').trim(),
+    // 处理MIME类型字符串:转换为小写,去除空格,按斜杠分割;获取主类型(如:application、text等)和子类型(处理包含斜杠的情况)
+    const parts = mimeType.toLowerCase().trim().split('/'), rootType = parts.shift().trim(),
+        subType = parts.join('/').trim(),
         fullMimeType = `${rootType}/${subType}`;         // 重新构建标准化的MIME类型字符串并查找对应的扩展名
     if (MIME_TYPES.has(fullMimeType)) {
         const value = MIME_TYPES.get(fullMimeType);
-        return Array.isArray(value) ? value[0] : value;  // 如果值是数组，返回第一个元素
+        return Array.isArray(value) ? value[0] : value;  // 如果值是数组,返回第一个元素
     }
 
     // 根据主类型返回默认扩展名
@@ -433,15 +438,15 @@ const detectExtension = (mimeType = '') => {
  * @returns {string} 检测到的MIME类型
  */
 const detectMimeType = filename => {
-    if (!filename) return defaultMimeType; // 如果文件名为空，返回默认MIME类型
+    if (!filename) return defaultMimeType; // 如果文件名为空,返回默认MIME类型
 
     const { ext, name = '' } = parse(filename),     // 解析文件路径获取扩展名
-        // 提取扩展名（去掉点号），处理查询参数，转换为小写
+        // 提取扩展名(去掉点号),处理查询参数,转换为小写
         extension = (ext.substring(1) || name).split('?').shift().trim().toLowerCase(),
 
-        // 如果在扩展名映射表中找到对应项，则使用对应的MIME类型
+        // 如果在扩展名映射表中找到对应项,则使用对应的MIME类型
         value = EXTENSIONS.has(extension) ? EXTENSIONS.get(extension) : defaultMimeType;
-    return Array.isArray(value) ? value[0] : value; // 如果值是数组，返回第一个元素;否则返回值
+    return Array.isArray(value) ? value[0] : value; // 如果值是数组,返回第一个元素;否则返回值
 };
 
 /**
@@ -449,7 +454,7 @@ const detectMimeType = filename => {
  * >查看定义:@see {@link foldLines}
  • @param {String} str 要折叠的字符串
  • @param {Number} [lineLength=76] 一行的最大长度
- • @param {Boolean} afterSpace 如果为true，在行尾留一个空格
+ • @param {Boolean} afterSpace 如果为true,在行尾留一个空格
  • @return {String} 带有折叠行的字符串
  */
 const foldLines = (str = '', lineLength = 76, afterSpace) => {

package/lib/mime-funcs/mime-types.js

@@ -1102,7 +1102,8 @@ const EXTENSIONS = new Map([
     ['bdm', 'application/vnd.syncml.dm+wbxml'],
     ['bed', 'application/vnd.realvnc.bed'],
     ['bh2', 'application/vnd.fujitsu.oasysprs'],
-    ['bin', ['application/octet-stream', 'application/mac-binary', 'application/macbinary', 'application/x-macbinary', 'application/x-binary']],
+    ['bin', ['application/octet-stream', 'application/mac-binary', 'application/macbinary', 'application/x-macbinary',
+        'application/x-binary']],
     ['bm', 'image/bmp'],
     ['bmi', 'application/vnd.bmi'],
     ['bmp', ['image/bmp', 'image/x-windows-bmp']],
@@ -1147,7 +1148,8 @@ const EXTENSIONS = new Map([
     ['cii', 'application/vnd.anser-web-certificate-issue-initiation'],
     ['cil', 'application/vnd.ms-artgalry'],
     ['cla', 'application/vnd.claymore'],
-    ['class', ['application/octet-stream', 'application/java', 'application/java-byte-code', 'application/java-vm', 'application/x-java-class']],
+    ['class', ['application/octet-stream', 'application/java', 'application/java-byte-code', 'application/java-vm',
+        'application/x-java-class']],
     ['clkk', 'application/vnd.crick.clicker.keyboard'],
     ['clkp', 'application/vnd.crick.clicker.palette'],
     ['clkt', 'application/vnd.crick.clicker.template'],
@@ -1407,7 +1409,8 @@ const EXTENSIONS = new Map([
     ['jpgv', 'video/jpeg'],
     ['jpm', 'video/jpm'],
     ['jps', 'image/x-jps'],
-    ['js', ['application/javascript', 'application/ecmascript', 'text/javascript', 'text/ecmascript', 'application/x-javascript']],
+    ['js', ['application/javascript', 'application/ecmascript', 'text/javascript', 'text/ecmascript',
+        'application/x-javascript']],
     ['json', 'application/json'],
     ['jut', 'image/jutvision'],
     ['kar', ['audio/midi', 'music/x-karaoke']],
@@ -1484,7 +1487,8 @@ const EXTENSIONS = new Map([
     ['mgz', 'application/vnd.proteus.magazine'],
     ['mht', 'message/rfc822'],
     ['mhtml', 'message/rfc822'],
-    ['mid', ['audio/mid', 'audio/midi', 'music/crescendo', 'x-music/x-midi', 'audio/x-midi', 'application/x-midi', 'audio/x-mid']],
+    ['mid', ['audio/mid', 'audio/midi', 'music/crescendo', 'x-music/x-midi', 'audio/x-midi', 'application/x-midi',
+        'audio/x-mid']],
     ['midi', ['audio/midi', 'music/crescendo', 'x-music/x-midi', 'audio/x-midi', 'application/x-midi', 'audio/x-mid']],
     ['mif', ['application/vnd.mif', 'application/x-mif', 'application/x-frame']],
     ['mime', ['message/rfc822', 'www/mime']],
@@ -1669,7 +1673,8 @@ const EXTENSIONS = new Map([
     ['pps', ['application/vnd.ms-powerpoint', 'application/mspowerpoint']],
     ['ppsm', 'application/vnd.ms-powerpoint.slideshow.macroenabled.12'],
     ['ppsx', 'application/vnd.openxmlformats-officedocument.presentationml.slideshow'],
-    ['ppt', ['application/vnd.ms-powerpoint', 'application/mspowerpoint', 'application/powerpoint', 'application/x-mspowerpoint']],
+    ['ppt', ['application/vnd.ms-powerpoint', 'application/mspowerpoint', 'application/powerpoint',
+        'application/x-mspowerpoint']],
     ['pptm', 'application/vnd.ms-powerpoint.presentation.macroenabled.12'],
     ['pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
     ['ppz', 'application/mspowerpoint'],
@@ -1752,7 +1757,8 @@ const EXTENSIONS = new Map([
     ['sbml', 'application/sbml+xml'],
     ['sc', 'application/vnd.ibm.secure-container'],
     ['scd', 'application/x-msschedule'],
-    ['scm', ['application/vnd.lotus-screencam', 'video/x-scm', 'text/x-script.guile', 'application/x-lotusscreencam', 'text/x-script.scheme']],
+    ['scm', ['application/vnd.lotus-screencam', 'video/x-scm', 'text/x-script.guile', 'application/x-lotusscreencam',
+        'text/x-script.scheme']],
     ['scq', 'application/scvp-cv-request'],
     ['scs', 'application/scvp-cv-response'],
     ['sct', 'text/scriptlet'],