@flun/mailer 2.1.23 → 2.1.25

package/lib/shared.js

@@ -31,7 +31,7 @@ const dnsLookup = dns.lookup;
  */
 const dnsResolve = dns.resolve,
     /**
-     * @param {number} family - IP地址族（4=IPv4, 6=IPv6）
+     * @param {number} family - IP地址族(4=IPv4, 6=IPv6)
      * @param {boolean} allowInternal - 是否允许内部网络接口
      * @returns {boolean} 是否支持该地址族
      */
@@ -42,7 +42,7 @@ const dnsResolve = dns.resolve,
             return !netInter ? true : Object.values(netInter).flat()
                 .some(i => (!i.internal || allowInternal) && (i.family === `IPv${family}` || i.family === family));
         } catch (err) {
-            console.error('获取网络接口信息失败：', err);
+            console.error('获取网络接口信息失败:', err);
             return true;
         }
 
@@ -58,12 +58,15 @@ const dnsResolve = dns.resolve,
     _resolver = (family, hostname, options = {}, callback) => {
         // 检查地址族是否支持
         if (!_isFamilySupported(family, options.allowInternalNetworkInterfaces)) return callback(null, []);
-        const resolver = dns.Resolver ? new dns.Resolver(options) : dns,              // 创建DNS解析器实例或使用默认的dns模块
+// 创建DNS解析器实例或使用默认的dns模块
+        const resolver = dns.Resolver ? new dns.Resolver(options) : dns,
 
             // 可忽略的DNS错误代码列表
-            dnsErrs = new Set([dns.NODATA, dns.NOTFOUND, dns.NOTIMP, dns.SERVFAIL, dns.CONNREFUSED, dns.REFUSED, 'EAI_AGAIN']);
+            dnsErrs = new Set([dns.NODATA,
+                dns.NOTFOUND, dns.NOTIMP, dns.SERVFAIL, dns.CONNREFUSED, dns.REFUSED, 'EAI_AGAIN']);
         resolver[`resolve${family}`](hostname, (err, addresses) => {
-            if (err) return callback(dnsErrs.has(err?.code) ? null : err, []);        // 处理特定的DNS错误代码,返回空数组而不是错误
+// 处理特定的DNS错误代码,返回空数组而不是错误
+            if (err) return callback(dnsErrs.has(err?.code) ? null : err, []);
             const result = Array.isArray(addresses) ? addresses : [addresses].flat(); // 确保返回的是数组
             return callback(null, result);
         });
@@ -89,7 +92,7 @@ const dnsResolve = dns.resolve,
      * 处理可读流的 readable 事件
      * @param {stream.Readable} stream 可读流实例
      * @param {Buffer[]} chunkArr 存储数据块的数组
-     * @param {{value: number}} lenRef 包含value属性的对象，用于累加数据长度
+     * @param {{value: number}} lenRef 包含value属性的对象,用于累加数据长度
      */
     _handleReadableStream = (stream, chunkArr, lenRef) => {
         let chunk;
@@ -100,7 +103,7 @@ const dnsResolve = dns.resolve,
 
     /**
     * 回调错误处理函数
-    * @param {Object} state 状态对象，包含returned属性
+    * @param {Object} state 状态对象,包含returned属性
     * @param {Object} connection 连接对象
     * @param {Function} callback 回调函数
     * @param {Error} err 错误对象
@@ -112,7 +115,7 @@ const dnsResolve = dns.resolve,
     },
 
     /**
-     * 生成一个类似bunyan的日志记录器，输出到控制台
+     * 生成一个类似bunyan的日志记录器,输出到控制台
      * @param {array} levels - 日志级别数组
      * @returns {object} Bunyan日志记录器实例
      */
@@ -137,7 +140,7 @@ const dnsResolve = dns.resolve,
                 const prefix = buildPrefix(entry), formattedMessage = format(message, ...args),// 构建前缀,格式化消息
                     timestamp = new Date().toISOString().substring(0, 19).replace('T', ' ');        // 格式化时间戳
 
-                // 分行打印（处理多行消息）
+                // 分行打印(处理多行消息)
                 formattedMessage.split(regexs.LINE_SEPARATOR).forEach(line => {
                     console.log('[%s] %s %s', timestamp, levelNames.get(level), prefix + line);
                 });
@@ -162,32 +165,34 @@ const dnsResolve = dns.resolve,
 /**
  * 返回bunyan兼容的日志记录器接口
  * 查看定义:@see {@link getLogger}
- * @param {object} options - 配置选项，可能包含'logger'
+ * @param {object} options - 配置选项,可能包含'logger'
  * @return {object} bunyan兼容的日志记录器
  */
 const getLogger = (options = {}, defaults) => {
     const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'], { logger } = options;
-    if (!logger) return Object.fromEntries(levels.map(level => [level, () => false])); // 如果没有提供日志记录器，创建空实现
+    if (!logger) return Object.fromEntries(levels.map(level => [level, () => false])); // 如果没有提供日志记录器,创建空实现
 
-    const logger_ = logger === true ? _createDefaultLogger(levels) : logger;          // 如果logger为true,创建控制台日志记录器
+// 如果logger为true,创建控制台日志记录器
+    const logger_ = logger === true ? _createDefaultLogger(levels) : logger;
     // 包装日志方法
     return Object.fromEntries(
-        levels.map(level => [level, (data, message, ...args) => _logFunc(logger_, level, defaults, data, message, ...args)])
+        levels.map(level => [level,
+            (data, message, ...args) => _logFunc(logger_, level, defaults, data, message, ...args)])
     );
 };
 
 /**
- * 解析主机名，支持IPv4/IPv6和DNS缓存
+ * 解析主机名,支持IPv4/IPv6和DNS缓存
  * >查看定义:@see {@link resolveHostname}
  * @param {object} options - 配置选项
  * @param {function} callback - 回调函数
  */
 const resolveHostname = (options = {}, callback) => {
     const { host, servername: sName, dnsTtl } = options,
-        // 如果没有host但有servername，使用servername作为host;如果都没有,设置servername为false
+        // 如果没有host但有servername,使用servername作为host;如果都没有,设置servername为false
         newHost = !host && sName ? sName : host, servername = sName || newHost || false;
 
-    // 如果host是IP地址或为空，直接返回
+    // 如果host是IP地址或为空,直接返回
     if (!newHost || isIP(newHost)) {
         const value = { addresses: [newHost], servername };
         return callback(null, _formatDNSValue(value, { cached: false }));
@@ -197,8 +202,9 @@ const resolveHostname = (options = {}, callback) => {
     let cached;
     if (DNS_MAP.has(newHost)) {
         cached = DNS_MAP.get(newHost);
-        // 如果缓存未过期，使用缓存值
-        if (!cached.expires || cached.expires >= Date.now()) return callback(null, _formatDNSValue(cached.value, { cached: true }));
+        // 如果缓存未过期,使用缓存值
+        if (!cached.expires || cached.expires >= Date.now()) return callback(null,
+            _formatDNSValue(cached.value, { cached: true }));
     }
 
     // 处理解析错误
@@ -214,10 +220,10 @@ const resolveHostname = (options = {}, callback) => {
 
     // 首先尝试IPv4解析
     _resolver(4, newHost, options, (err, addrV4) => {
-        if (err) return handleError(err);                           // 如果出错但有缓存，使用过期的缓存值,否则返回错误
+        if (err) return handleError(err);                           // 如果出错但有缓存,使用过期的缓存值,否则返回错误
         if (addrV4?.length) return handleSuccess(addrV4);           // 如果IPv4解析成功,更新DNS缓存,返回成功
 
-        // IPv4失败，尝试IPv6解析
+        // IPv4失败,尝试IPv6解析
         _resolver(6, newHost, options, (err, addrV6) => {
             if (err) return handleError(err);
             if (addrV6?.length) return handleSuccess(addrV6);      // 如果IPv6解析成功,同理...
@@ -229,10 +235,10 @@ const resolveHostname = (options = {}, callback) => {
                     // 过滤出系统支持的地址族的地址(取第一个支持的地址)
                     const address = lookupAddr?.find(addr => _isFamilySupported(addr.family))?.address || false;
 
-                    // 如果有地址但没有可用的，输出警告
+                    // 如果有地址但没有可用的,输出警告
                     if (lookupAddr?.length && !address) console.warn(`无法使用当前网络解析IPv${lookupAddr[0].family}地址`);
 
-                    // 如果没有找到地址但有缓存，使用缓存;否则,使用找到的地址或原始主机名
+                    // 如果没有找到地址但有缓存,使用缓存;否则,使用找到的地址或原始主机名
                     return !address && cached ? callback(null, _formatDNSValue(cached.value, { cached: true })) :
                         handleSuccess(address ? [address] : [newHost]);
                 });
@@ -244,8 +250,8 @@ const resolveHostname = (options = {}, callback) => {
 /**
  * 尝试将给定的字符串解析为URL对象
  * >查看定义:@see {@link newURL}
- * @param {string} str - 需要解析的URL字符串，默认为空字符串
- * @returns {URL|boolean} 如果解析成功返回URL对象，否则返回false
+ * @param {string} str - 需要解析的URL字符串,默认为空字符串
+ * @returns {URL|boolean} 如果解析成功返回URL对象,否则返回false
  */
 const newURL = (str = '') => {
     try {
@@ -271,9 +277,11 @@ const parseConnectionUrl = str => {
             return val;
         },
         options = {
-            ...protocols[url.protocol], ...(url.port && { port: Number(url.port) }), ...(url.hostname && { host: url.hostname }),
+            ...protocols[url.protocol], ...(url.port && { port: Number(url.port) }),
+                ...(url.hostname && { host: url.hostname }),
             ...((url.username || url.password) && {
-                auth: { user: decodeURIComponent(url.username), pass: url.password ? decodeURIComponent(url.password) : '' }
+                auth: { user: decodeURIComponent(url.username),
+                    pass: url.password ? decodeURIComponent(url.password) : '' }
             })
         };
 
@@ -301,11 +309,12 @@ const parseDataURI = uri => {
     if (typeof uri !== 'string' || !uri.startsWith('data:')) return null; // 检查参数是否为字符串且以data:开头
 
     const commaIndex = uri.indexOf(',');          // 安全地查找第一个逗号的索引 -防止ReDoS攻击
-    if (commaIndex === -1) return null;           // 如果没有找到逗号，返回
+    if (commaIndex === -1) return null;           // 如果没有找到逗号,返回
 
     const data = uri.slice(commaIndex + 1), metaStr = uri.slice(5, commaIndex), metaEntries = metaStr.split(';'),
-        // 提取编码类型（最后一个非键值对参数）
-        lastEntry = metaEntries.at(-1)?.toLowerCase().trim(), contentType = metaEntries.shift() || 'application/octet-stream',
+        // 提取编码类型(最后一个非键值对参数)
+        lastEntry = metaEntries.at(-1)?.toLowerCase().trim(),
+            contentType = metaEntries.shift() || 'application/octet-stream',
         encoding = ['base64', 'utf8', 'utf-8'].includes(lastEntry) && !lastEntry.includes('=') ? metaEntries.pop() : null,
         // 解析参数为键值对
         params = Object.fromEntries(
@@ -375,7 +384,7 @@ const resolveStream = (stream, callback) => {
  * @returns {Promise|null} 可能返回Promise
  */
 const resolveContent = (data, key, callback) => {
-    // 如果没有提供回调，创建Promise
+    // 如果没有提供回调,创建Promise
     const promise = !callback ? new Promise((resolve, reject) => callback = callbackPromise(resolve, reject)) : null;
 
     let content = data?.[key]?.content ?? data?.[key];
@@ -389,16 +398,17 @@ const resolveContent = (data, key, callback) => {
     // 处理不同类型的content
     if (typeof content === 'object') {
         const { path, href, pipe } = content, source = path || href;
-        // 如果content是流，则解析
+        // 如果content是流,则解析
         if (typeof pipe === 'function')
             return resolveStream(content, (err, value) => {
                 if (err) return callback(err);
-                data[key]?.content ? data[key].content = value : data[key] = value;  // 不能两次流式传输相同内容,所以需要替换流对象
+// 不能两次流式传输相同内容,所以需要替换流对象
+                data[key]?.content ? data[key].content = value : data[key] = value;
                 callback(null, value);
             });
-        // 否则，如果content是URL，则解析URL
+        // 否则,如果content是URL,则解析URL
         else if (regexs.HTTP_URL.test(source)) return resolveStream(nmfetch(source), callback);
-        // 否则,如果content是Data URI，则解析Data URI
+        // 否则,如果content是Data URI,则解析Data URI
         else if (regexs.DATA_URL.test(source)) return callback(null, parseDataURI(source)?.data || Buffer.alloc(0));
         // 处理文件路径
         else if (path) return resolveStream(fsReadStream(path), callback);
@@ -406,8 +416,9 @@ const resolveContent = (data, key, callback) => {
 
     // 处理特定编码的字符串
     const keyC = data[key]?.content;
-    if (typeof keyC === 'string' && !['utf8', 'usascii', 'ascii'].includes(encoding)) content = Buffer.from(keyC, encoding);
-    setImmediate(() => callback(null, content)); // 默认操作，原样返回内容
+    if (typeof keyC === 'string' && !['utf8', 'usascii', 'ascii'].includes(encoding)) content = Buffer.from(keyC,
+        encoding);
+    setImmediate(() => callback(null, content)); // 默认操作,原样返回内容
     return promise;
 };
 
@@ -417,26 +428,26 @@ const resolveContent = (data, key, callback) => {
  * @returns {object} 目标对象
  */
 const assign = (target, ...sources) => {
-    target = target && typeof target === 'object' ? target : {};  // 确保 target 是对象，如果是假值则重置为空对象
+    target = target && typeof target === 'object' ? target : {};  // 确保 target 是对象,如果是假值则重置为空对象
 
     for (const source of sources) {
         if (!source) continue;
         for (const [k, v] of Object.entries(source))
-            // 如果key是tls或auth，并且value是对象，则递归合并对象
+            // 如果key是tls或auth,并且value是对象,则递归合并对象
             target[k] = ['tls', 'auth'].includes(k) && v && typeof v === 'object' ? { ...target[k], ...v } : v;
     }
     return target;
 };
 
 /**
- * 对字符串进行XText编码（SMTP扩展）
+ * 对字符串进行XText编码(SMTP扩展)
  * >查看定义:@see {@link encodeXText}
  * @param {string} str - 要编码的字符串
  * @returns {string} 编码后的字符串
  */
 const encodeXText = str => {
     if (!regexs.NEED_ENCODING.test(str)) return str;
-    // 将字符串转换为字节数组，对需要编码的字符转换为"+十六进制"格式，否则保留原字符，最后拼接成字符串
+    // 将字符串转换为字节数组,对需要编码的字符转换为"+十六进制"格式,否则保留原字符,最后拼接成字符串
     return Array.from(Buffer.from(str)).map(c => c < 0x21 || c > 0x7E || c === 0x2B || c === 0x3D
         ? `+${c.toString(16).toUpperCase().padStart(2, '0')}` : String.fromCharCode(c)).join('');
 };
@@ -457,7 +468,7 @@ const initSmtpConstructor = (instance, options, SmtpC, defaultComponent) => {
     let urlData, service = s;
     if (url) urlData = parseConnectionUrl(url), service = service || urlData.service; // 解析URL连接选项
 
-    // 合并选项：是否创建对象、常规选项、URL选项和知名服务选项
+    // 合并选项:是否创建对象、常规选项、URL选项和知名服务选项
     instance.options = assign(false, options, urlData, service && wellKnown(service));
     const connection = new SmtpC(instance.options); // 创建临时连接对象用于获取版本信息
     instance.version = `${PK.version}[client:${connection.version}]`;
@@ -470,7 +481,7 @@ const initSmtpConstructor = (instance, options, SmtpC, defaultComponent) => {
  * 用于创建代理套接字的占位函数,此方法立即返回而不提供套接字
  * >查看定义:@see {@link getSocket}
  * @param {Object} options 连接选项
- * @param {Function} callback 回调函数，用于处理套接字密钥
+ * @param {Function} callback 回调函数,用于处理套接字密钥
  */
 const getSocket = (options, callback) => {
     return setImmediate(() => callback(null, false)); // 立即返回空套接字
@@ -500,7 +511,8 @@ const createSmtpConnection = (transport, socketOptions, SmtpC) => {
     // 处理代理socket情况
     if (socketOptions?.connection) {
         const { remoteAddress, remotePort } = socketOptions.connection, { host = '', port = '' } = newOptions;
-        transport.logger.info({ tnx: 'proxy', remoteAddress, remotePort, destHost: host, destPort: port, action: 'connected' },
+        transport.logger.info({ tnx: 'proxy', remoteAddress, remotePort, destHost: host, destPort: port,
+            action: 'connected' },
             '使用来自 %s:%s 到 %s:%s 的代理socket', remoteAddress, remotePort, host, port
         );
         newOptions = { ...assign(false, newOptions), ...socketOptions };
@@ -569,7 +581,7 @@ const performSmtpAuthentication = (state, connection, auth, options, callback, t
         const err = new Error('未提供认证信息');
         err.code = 'NoAuth', _callbackErr(state, connection, callback, err, transport);
     }
-    else onSuccess(); // 否则，直接执行成功回调
+    else onSuccess(); // 否则,直接执行成功回调
 };
 
 /**
@@ -577,7 +589,7 @@ const performSmtpAuthentication = (state, connection, auth, options, callback, t
  * >查看定义:@see {@link createAuthConfig}
  * @param {Object} authData 认证数据
  * @param {Object} logger 日志记录器
- * @param {Object} mailer 邮件器实例（可选）
+ * @param {Object} mailer 邮件器实例(可选)
  * @returns {Object|string} 认证配置对象或空字符串
  */
 const createAuthConfig = (authData, logger, mailer = null, OAUTH2) => {
@@ -585,7 +597,8 @@ const createAuthConfig = (authData, logger, mailer = null, OAUTH2) => {
 
     let hasAuth = false;
     const authConfig = {}, mergeAuthData = source => {
-        if (source?.constructor === Object && Object.keys(source).length > 0) Object.assign(authConfig, source), hasAuth = true;
+        if (source?.constructor === Object && Object.keys(source).length > 0) Object.assign(authConfig,
+            source), hasAuth = true;
     };
     mergeAuthData(authData);
 
@@ -616,29 +629,29 @@ const createAuthConfig = (authData, logger, mailer = null, OAUTH2) => {
  * >查看定义:@see {@link prepareMessageForSending}
  * @param {Object} mail 邮件对象
  * @param {Object} logger 日志记录器
- * @param {String} connectionId 连接ID（可选）
- * @param {Object} options 配置选项（可选）
- * @param {Function} done 发送时执行的回调函数（可选）
+ * @param {String} connectionId 连接ID(可选)
+ * @param {Object} options 配置选项(可选)
+ * @param {Function} done 发送时执行的回调函数(可选)
  * @returns {Object} 处理后的信封和消息信息
  */
 const prepareMessageForSending = (mail, logger, connectionId = '', options = {}, done) => {
     const { data, message, normalize } = mail, { envelope: En, dsn, _dkim, ses } = data, { _headers } = message;
-    message.keepBcc = true;     // 保留BCC字段（适用于所有传输类型）
+    message.keepBcc = true;     // 保留BCC字段(适用于所有传输类型)
 
     // 获取信封和消息ID
     const envelope = En || message.getEnvelope(), messageId = message.messageId(), { from, to } = envelope,
         rList = Array.from(to ?? []),
-        // 格式化收件人列表:仅显示前3个收件人，超过部分用省略号表示
+        // 格式化收件人列表:仅显示前3个收件人,超过部分用省略号表示
         recipients = rList.length > 3 ? [...rList.slice(0, 2), `...以及另外${rList.length - 2}个收件人`] : rList;
-    if (dsn) envelope.dsn = dsn; // 添加DSN信息（如果存在）
+    if (dsn) envelope.dsn = dsn; // 添加DSN信息(如果存在)
 
     // 构建日志上下文
     const logContext = { tnx: 'send', messageId, ...(connectionId && { cid: connectionId }) };
     let logMessage, logParams, args, fromAddress = from; // 通用日志记录 - 适配不同传输类型的日志格式
     if (options.transportType === 'json')
-        logMessage = '正在为 %s 构建JSON结构，收件人: <%s>', logParams = [messageId, recipients.join(', ')];
+        logMessage = '正在为 %s 构建JSON结构,收件人: <%s>', logParams = [messageId, recipients.join(', ')];
     else if (options.transportType === 'sendmail') {
-        // 检查无效地址格式（以连字符开头）
+        // 检查无效地址格式(以连字符开头)
         const hasInvalidAddresses = [...(from || []), ...(to || [])].some(addr => addr.startsWith('-'));
         if (hasInvalidAddresses) return done(new Error('无法发送邮件,信封地址无效;'));
         // 构建sendmail参数
@@ -651,13 +664,14 @@ const prepareMessageForSending = (mail, logger, connectionId = '', options = {},
             const fromHeader = _headers?.find(header => header.key.toLowerCase() === 'from');
             if (fromHeader?.value) fromAddress = fromHeader.value;
         } catch (err) {
-            logger.warn({ err, messageId }, '解析 From 头失败，使用默认发件人地址: %s', from);
+            logger.warn({ err, messageId }, '解析 From 头失败,使用默认发件人地址: %s', from);
         }
 
         logMessage = '正在发送消息 %s 至 <%s>', logParams = [messageId, recipients.join(', ')];
     } else if (options.transportType === 'stream') {
         const lineBreakType = options.winbreak ? '<CR><LF>' : '<LF>';
-        logMessage = '正在发送消息 %s 到 <%s>，使用 %s 换行符', logParams = [messageId, recipients.join(', '), lineBreakType];
+        logMessage = '正在发送消息 %s 到 <%s>,使用 %s 换行符',
+            logParams = [messageId, recipients.join(', '), lineBreakType];
     } else {
         // SMTP 和其他传输类型的默认日志格式
         logMessage = connectionId ? '正在使用资源 #%s 发送消息 %s 至 <%s>' : '正在发送消息 %s 给 <%s>';
@@ -665,7 +679,8 @@ const prepareMessageForSending = (mail, logger, connectionId = '', options = {},
     }
 
     logger.info(logContext, logMessage, ...logParams);
-    return { normalize, envelope, messageId, from: fromAddress, to, _dkim, ses, args, readStream: message.createReadStream() };
+    return { normalize, envelope, messageId, from: fromAddress, to, _dkim, ses, args,
+        readStream: message.createReadStream() };
 };
 
 /**
@@ -700,7 +715,7 @@ const handleSendResult = (result, callback, logger) => {
  * @param {Object} auth 认证信息
  */
 const verifySmtp = (transport, callback, SmtpC, auth = null) => {
-    // 如果没有提供回调，则创建Promise
+    // 如果没有提供回调,则创建Promise
     const promise = !callback ? new Promise((resolve, reject) => callback = callbackPromise(resolve, reject)) : null;
 
     getSocket(transport.options, (err, socketOp) => {
@@ -709,7 +724,7 @@ const verifySmtp = (transport, callback, SmtpC, auth = null) => {
             state = { returned: false }, // 标记是否返回对象
 
             finalize = (state, connection, callback) => {
-                cleanup(state), connection.quit(); // 对于验证操作，发送 QUIT 命令优雅关闭
+                cleanup(state), connection.quit(); // 对于验证操作,发送 QUIT 命令优雅关闭
                 return callback(null, true);
             };
 

package/lib/smtp-connection/data-stream.js

@@ -16,7 +16,7 @@ class DataStream extends Transform {
      * 转义点号的处理函数
      */
     _transform(chunk, encoding, done) {
-        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);   // 如果chunk是字符串，则将其转换为Buffer
+        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);   // 如果chunk是字符串,则将其转换为Buffer
         if (!chunk?.length) return done();                                     // 如果chunk为空则直接返回
         const chunks = [];
         let chunklen = 0, lastPos = 0, buf;
@@ -25,16 +25,17 @@ class DataStream extends Transform {
         // 遍历chunk中的每个字节
         for (let i = 0; i < chunk.length; i++) {
             if (chunk[i] === 0x2e) {
-                // 遇到点号(.)，检查是否在行首,如果在,那么在行首的点号前额外添加一个点号进行转义
+                // 遇到点号(.),检查是否在行首,如果在,那么在行首的点号前额外添加一个点号进行转义
                 if ((i && chunk[i - 1] === 0x0a) || (!i && (!this.lastByte || this.lastByte === 0x0a))) {
                     buf = chunk.slice(lastPos, i + 1), chunks.push(buf), chunks.push(Buffer.from('.'));
                     chunklen += buf.length + 1, lastPos = i + 1;
                 }
             }
             else if (chunk[i] === 0x0a) {
-                // 遇到换行符(\n)，检查前面是否有回车符(\r)
+                // 遇到换行符(\n),检查前面是否有回车符(\r)
                 if ((i && chunk[i - 1] !== 0x0d) || (!i && this.lastByte !== 0x0d)) {
-                    i > lastPos ? (buf = chunk.slice(lastPos, i), chunks.push(buf), chunklen += buf.length + 2) : chunklen += 2;
+                    i > lastPos ? (buf = chunk.slice(lastPos, i), chunks.push(buf), chunklen += buf.length + 2)
+                        : chunklen += 2;
                     chunks.push(Buffer.from('\r\n')), lastPos = i + 1;
                 }
             }
@@ -46,20 +47,20 @@ class DataStream extends Transform {
             if (lastPos < chunk.length) buf = chunk.slice(lastPos), chunks.push(buf), chunklen += buf.length;
             this.outByteCount += chunklen, this.push(Buffer.concat(chunks, chunklen));
         }
-        else this.outByteCount += chunk.length, this.push(chunk); // 没有需要转义的情况，直接推送原数据
+        else this.outByteCount += chunk.length, this.push(chunk); // 没有需要转义的情况,直接推送原数据
 
         this.lastByte = chunk.at(-1); done(); // 记录最后一个字节后,完成处理
     }
 
     /**
-     * 结束流处理，添加终止序列
+     * 结束流处理,添加终止序列
      */
     _flush(done) {
         let buf;
         // 根据最后一个字节的类型添加适当的终止序列
-        if (this.lastByte === 0x0a) buf = Buffer.from('.\r\n');        // 如果最后是LF，直接添加点号和CRLF
-        else if (this.lastByte === 0x0d) buf = Buffer.from('\n.\r\n'); // 如果最后是CR，添加LF、点号和CRLF
-        else buf = Buffer.from('\r\n.\r\n');                           // 其他情况，添加完整的CRLF、点号和CRLF
+        if (this.lastByte === 0x0a) buf = Buffer.from('.\r\n');        // 如果最后是LF,直接添加点号和CRLF
+        else if (this.lastByte === 0x0d) buf = Buffer.from('\n.\r\n'); // 如果最后是CR,添加LF、点号和CRLF
+        else buf = Buffer.from('\r\n.\r\n');                           // 其他情况,添加完整的CRLF、点号和CRLF
 
         this.outByteCount += buf.length, this.push(buf), done();
     }