@flun/mailer 2.1.4

package/lib/mime-node/last-newline.js

@@ -0,0 +1,44 @@
+import { Transform } from 'stream';
+
+/**
+ * 一个转换流,用于确保数据以正确的换行符结束;
+ * 继承自 stream.Transform
+ * >查看定义:@see {@link LastNewline}
+ */
+class LastNewline extends Transform {
+    constructor() {
+        super();
+        this.lastByte = false; // 保存最后一个字节用于判断换行状态
+    }
+
+    /**
+     * 转换数据处理方法
+     * @param {Buffer} chunk - 输入的数据块
+     * @param {string} encoding - 编码方式
+     * @param {function} done - 完成回调
+     */
+    _transform(chunk, encoding, done) {
+        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);   // 如果是字符串，转换为Buffer
+        if (chunk.length) this.lastByte = chunk.at(-1);                        // 如果数据块不为空，记录最后一个字节
+        this.push(chunk), done(); // 将数据块推送到下一个流;完成
+    }
+
+    /**
+     * 流结束时的处理逻辑
+     * @param {function} done - 完成回调
+     */
+    _flush(done) {
+        if (this.lastByte === 0x0a) return done();  // 如果最后一个字节是换行符，直接结束
+
+        // 如果最后一个字节是回车符，添加换行符
+        if (this.lastByte === 0x0d) {
+            this.push(Buffer.from('\n'));
+            return done();
+        }
+
+        this.push(Buffer.from('\r\n')); // 其他情况添加Windows风格的换行符\r\n
+        return done();
+    }
+}
+
+export { LastNewline }

package/lib/mime-node/le-unix.js

@@ -0,0 +1,37 @@
+import { Transform } from 'stream';
+
+/**
+ * 确保仅使用 `<LF>` 作为换行符(Windows风格处理);
+ * >查看定义:@see {@link LeUnix}
+ * @param {Object} options 流选项
+ */
+class LeUnix extends Transform {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+    }
+
+    /**
+     * 转换函数 - 处理数据块中的换行符
+     * @param {Buffer} chunk 数据块
+     * @param {string} encoding 编码格式
+     * @param {Function} done 完成回调
+     */
+    _transform(chunk, encoding, done) {
+        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);  // 如果chunk是字符串,根据encoding转换为Buffer
+        let buf, lastPos = 0;
+
+        // 遍历数据块中的每个字节
+        for (let i = 0; i < chunk.length; i++) {
+            // 如果,遇到回车符, 则提取从上次位置到当前回车符之前的数据(跳过回车符,推送处理后的数据)
+            if (chunk[i] === 0x0d) buf = chunk.subarray(lastPos, i), lastPos = i + 1, this.push(buf);
+        }
+
+        // 如果剩余数据为真，则推送最后一个回车符之后的数据
+        if (lastPos && lastPos < chunk.length) buf = chunk.subarray(lastPos), this.push(buf);
+        else if (!lastPos) this.push(chunk); // 否则, 如果没有找到回车符，直接推送整个数据块
+        done();
+    }
+}
+
+export { LeUnix };

package/lib/mime-node/le-windows.js

@@ -0,0 +1,46 @@
+import { Transform } from 'stream';
+
+/**
+ * 确保只使用 `<CR><LF>` 序列作为换行符(Windows风格处理)
+ * >查看定义:@see {@link LeWindows}
+ * @param {Object} options 流选项
+ */
+class LeWindows extends Transform {
+    constructor(options = {}) {
+        super(options);
+        this.options = options, this.lastByte = false;  // 记录上一个字节，用于跨 chunk 的换行符检测
+    }
+
+    /**
+     * 转换函数：确保所有换行符都是 \r\n 格式
+     */
+    _transform(chunk, encoding, done) {
+        if (chunk.length === 0) return done();
+        if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);  // 如果chunk是字符串,根据encoding转换为Buffer
+
+        // 快速路径：无换行符直接推送
+        if (!chunk.includes(0x0a)) {
+            this.push(chunk), this.lastByte = chunk.at(-1);
+            return done();
+        }
+
+        const crlf = Buffer.from('\r\n'), output = [];
+        let start = 0;
+
+        for (let i = 0; i < chunk.length; i++) {
+            if (chunk[i] !== 0x0a) continue;    // 跳过非换行符
+
+            const prevByte = i === 0 ? this.lastByte : chunk[i - 1];
+            if (prevByte === 0x0d) continue;   // 已有 \r 前缀则跳过
+            if (i > start) output.push(chunk.slice(start, i)); // 发现需要转换的换行符
+            output.push(crlf), start = i + 1;  // 跳过当前 \n
+        }
+
+        if (start < chunk.length) output.push(chunk.slice(start));  // 添加剩余数据
+        // 输出结果
+        const result = output.length ? Buffer.concat(output) : chunk;
+        this.push(result), this.lastByte = chunk.at(-1), done();
+    }
+}
+
+export { LeWindows };

package/lib/punycode.js

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

package/lib/qp.js

@@ -0,0 +1,171 @@
+import { Transform } from 'stream';
+import { regexs, resetRegex } from './regexs.js';
+
+/**
+ * 为Quoted-Printable字符串添加软换行
+ *
+ * @param {String} str 可能需要换行的Quoted-Printable编码字符串
+ * @param {Number} [lineLength=76] 每行的最大允许长度
+ * @returns {String} 经过软换行处理的Quoted-Printable编码字符串
+ */
+const qpWrap = (str = '', lineLength = 76) => {
+    str = str.toString();
+    if (str.length <= lineLength) return str;  // 如果字符串长度不超过行限制，直接返回
+    let pos = 0, match, code, line, result = '';
+    const len = str.length, lineMargin = Math.floor(lineLength / 3),
+        // 将行添加到结果中并更新位置
+        addLineAndUpdatePos = currentLine => { result += currentLine, pos += currentLine.length };
+
+    // 在需要的位置插入软换行
+    while (pos < len) {
+        line = str.slice(pos, pos + lineLength);
+        // 处理已有的CRLF换行
+        if ((match = line.includes('\r\n'))) {
+            line = line.slice(0, match.index + match[0].length), addLineAndUpdatePos(line);
+            continue;
+        }
+
+        // 如果以换行符结尾，保持不变
+        if (line.endsWith('\n')) {
+            addLineAndUpdatePos(line);
+            continue;
+        }
+        else if ((match = line.slice(-lineMargin).match(regexs.TRAILING_NEWLINE))) {
+            line = line.slice(0, line.length - (match[0].length - 1)), addLineAndUpdatePos(line); // 截断到最近的换行符
+            continue;
+        }
+        else if (line.length > lineLength - lineMargin && (match = line.slice(-lineMargin).match(regexs.TRAILING_SPACE_OR_PUNCTUATION)))
+            line = line.slice(0, line.length - (match[0].length - 1));  // 截断到最近的空格
+        else if (line.match(regexs.INCOMPLETE_ENCODING)) {
+            // 将不完整的编码序列推到下一行
+            if ((match = line.match(regexs.INCOMPLETE_ENCODING_SHORT))) line = line.slice(0, line.length - match[0].length);
+
+            const rCE = resetRegex(regexs.COMPLETE_ENCODING);
+            // 确保UTF-8序列不被分割
+            while (line.length > 3 && line.length < len - pos && !line.match(regexs.UTF8_ENCODING) && (match = line.match(rCE))) {
+                code = parseInt(match[0].slice(1, 3), 16);
+                if (code < 128) break;
+
+                line = line.slice(0, line.length - 3);
+                if (code >= 0xc0) break;
+            }
+        }
+
+        // 添加软换行
+        if (pos + line.length < len && line.endsWith('\n')) {
+            const rCE = resetRegex(regexs.COMPLETE_ENCODING);
+            if (line.length === lineLength && line.match(rCE)) line = line.slice(0, line.length - 3);
+            else if (line.length === lineLength) line = line.slice(0, line.length - 1);
+
+            pos += line.length, line += '=\r\n';
+        }
+        else pos += line.length;
+
+        result += line;
+    }
+
+    return result;
+},
+
+    /**
+     * 辅助函数：检查数字是否在指定范围内
+     *
+     * @param {Number} nr 要检查的数字
+     * @param {Array} ranges 允许的值范围数组
+     * @returns {Boolean} 如果在允许范围内返回true，否则返回false
+     */
+    checkRanges = (nr, ranges) => {
+        for (let i = ranges.length - 1; i >= 0; i--) {
+            if (!ranges[i].length) continue;                                 // 如果范围为空，则跳过
+            if (ranges[i].length === 1 && nr === ranges[i][0]) return true;  // 如果范围只有一个值，则直接比较
+            if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) return true;// 如果范围有两个值,则比较是否在范围内
+        }
+        return false;
+    };
+
+/**
+ * 将Buffer编码为Quoted-Printable格式的字符串
+ * >查看定义:@see {@link qpEncode}
+ * @param {Buffer} buffer 要转换的Buffer
+ * @returns {String} Quoted-Printable编码的字符串
+ */
+const qpEncode = buffer => {
+    if (typeof buffer === 'string') buffer = Buffer.from(buffer, 'utf-8'); // 如果输入是字符串，先转换为Buffer
+
+    // 不需要编码的可用字符范围
+    const ranges = [
+        // https://tools.ietf.org/html/rfc2045#section-6.7
+        [0x09], [0x0a], [0x0d],  // <TAB>,<LF>,<CR>
+        [0x20, 0x3c],            // <SP>!"#$%&'()*+,-./0123456789:;
+        [0x3e, 0x7e]             // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
+    ];
+    let result = '';
+
+    // 遍历buffer中的每个字节
+    for (let i = 0, len = buffer.length; i < len; i++) {
+        const ord = buffer[i], nextByte = buffer[i + 1];
+
+        // 如果字符在允许范围内，并且不是行尾的空格或制表符，则直接使用原字符
+        if (checkRanges(ord, ranges) && !((ord === 0x20 || ord === 0x09) && (i === len - 1 || nextByte === 0x0a
+            || nextByte === 0x0d))) {
+            result += String.fromCharCode(ord);
+            continue;
+        }
+        result += `=${(ord < 0x10 ? '0' : '')}${ord.toString(16).toUpperCase()}`; // 否则进行编码：=后跟两位十六进制数
+    }
+
+    return result;
+};
+
+/**
+ * 创建用于将数据编码为Quoted-Printable格式的转换流
+ * >查看定义:@see {@link QpEncoder}
+ * @constructor
+ * @param {Object} options 流选项
+ * @param {Number} [options.lineLength=76] 行最大长度,设置为false可禁用换行
+ */
+class QpEncoder extends Transform {
+    constructor(options = {}) {
+        super();
+        this.options = options; // 初始化
+        const { lineLength = 76 } = this.options;
+        if (lineLength !== false) this.options.lineLength = lineLength; // 设置行长度,默认为76
+        this._curLine = '', this.inputBytes = 0, this.outputBytes = 0;  // 当前行缓存和统计输入输出字节数
+    }
+
+    /**
+     * 转换数据块
+     */
+    _transform(chunk, encoding, done) {
+        let qp;
+        if (encoding !== 'buffer') chunk = Buffer.from(chunk, encoding);  // 确保chunk是Buffer类型
+        if (!chunk?.length) return done();                                // 空数据块直接返回
+        this.inputBytes += chunk.length;
+
+        // 如果启用了行长度限制
+        const { lineLength } = this.options;
+        if (lineLength) {
+            // 编码并添加换行
+            qp = qpWrap(this._curLine + qpEncode(chunk), lineLength);
+            qp = qp.replace(regexs.LAST_LINE, (_, lineBreak, lastLine) => {
+                this._curLine = lastLine;
+                return lineBreak;
+            });
+
+            if (qp) this.outputBytes += qp.length, this.push(qp);
+        }
+        // 否则没有启用行长度限制，直接编码并输出
+        else qp = qpEncode(chunk), this.outputBytes += qp.length, this.push(qp, 'ascii');
+        done();
+    }
+
+    /**
+     * 刷新流，输出剩余数据
+     */
+    _flush(done) {
+        if (this._curLine) this.outputBytes += this._curLine.length, this.push(this._curLine, 'ascii');
+        done();
+    }
+}
+
+export { qpEncode, QpEncoder };