libbase64 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.3.2](https://github.com/nodemailer/libbase64/compare/v1.3.1...v1.3.2) (2026-10-04)
+
+
+### Bug Fixes
+
+* **encoder:** wrap base64 lines without regular expressions, independent of chunk boundaries ([2c76a48](https://github.com/nodemailer/libbase64/commit/2c76a489f1444600b5645a44c933e159ac8e920f))
+
 ## [1.3.1](https://github.com/nodemailer/libbase64/compare/v1.3.0...v1.3.1) (2026-09-28)
 
 

package/lib/libbase64.js

@@ -45,6 +45,52 @@ function decode(str) {
     return Buffer.from(str, 'base64');
 }
 
+/**
+ * Turns a line length option into a whole number of characters, the default for anything unusable
+ */
+function normalizeLineLength(lineLength) {
+    lineLength = Math.floor(Number(lineLength));
+    return Number.isFinite(lineLength) && lineLength >= 1 ? lineLength : 76;
+}
+
+/**
+ * Splits the bytes of `src` into lines of `lineLength` bytes, each followed by a line break. With
+ * `final` set the last line, which may be shorter, gets no line break; otherwise only complete lines
+ * are taken and the rest is left for the caller
+ *
+ * @param {Buffer} src Bytes to wrap
+ * @param {Number} lineLength Line length
+ * @param {Boolean} final Whether `src` ends the output
+ * @returns {Object} `{ output, rest }`: the wrapped bytes and the number of trailing bytes not taken
+ */
+function wrapBuffer(src, lineLength, final) {
+    let lines = Math.ceil(src.length / lineLength);
+    // the last line waits for more data unless this is the end: whether it gets a line break depends on
+    // whether anything follows it
+    let complete = Math.max(lines - 1, 0);
+    let rest = src.length - complete * lineLength;
+
+    let output = Buffer.allocUnsafe(complete * (lineLength + 2) + (final ? rest : 0));
+    let to = 0;
+    for (let from = 0; from < complete * lineLength; from += lineLength) {
+        src.copy(output, to, from, from + lineLength);
+        to += lineLength;
+        output[to++] = 0x0d;
+        output[to++] = 0x0a;
+    }
+    if (final) {
+        to += src.copy(output, to, complete * lineLength);
+        rest = 0;
+    }
+
+    if (to !== output.length) {
+        // never hand out bytes of the unfilled allocation
+        throw new Error('Unexpected wrapped length');
+    }
+
+    return { output, rest };
+}
+
 /**
  * Adds soft line breaks to a base64 string
  *
@@ -54,12 +100,26 @@ function decode(str) {
  */
 function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
+    lineLength = normalizeLineLength(lineLength);
 
     if (str.length <= lineLength) {
         return str;
     }
 
+    // eslint-disable-next-line no-control-regex
+    if (/[^\u0000-\u00ff]|[\r\n]/.test(str) || str.trim() !== str) {
+        // not a plain base64 string, keep the line based behaviour for whatever this is
+        return legacyWrap(str, lineLength);
+    }
+
+    return wrapBuffer(Buffer.from(str, 'latin1'), lineLength, true).output.toString('latin1');
+}
+
+/**
+ * Line wrapping for input that is not a plain base64 string: line breaks already in the input end a
+ * line, and surrounding whitespace is trimmed
+ */
+function legacyWrap(str, lineLength) {
     let result = [];
     let pos = 0;
     let chunkLength = lineLength * 1024;
@@ -78,9 +138,15 @@ function wrap(str, lineLength) {
 /**
  * Creates a transform stream for encoding data to base64 encoding
  *
+ * The output is the same as `wrap(encode(input), lineLength)` no matter how the input is split into
+ * chunks: every line but the last one ends with a line break, the last one does not
+ *
  * @constructor
  * @param {Object} options Stream options
  * @param {Number} [options.lineLength=76] Maximum lenght for lines, set to false to disable wrapping
+ * @param {Number} [options.skipStartBytes] Number of output bytes to drop from the start
+ * @param {Number} [options.limitOutputBytes] Maximum number of output bytes to emit
+ * @param {String} [options.startPadding] Characters to prepend to the first line before wrapping
  */
 class Encoder extends Transform {
     constructor(options) {
@@ -89,40 +155,42 @@ class Encoder extends Transform {
         this.options = options || {};
 
         if (this.options.lineLength !== false) {
-            this.options.lineLength = Number(this.options.lineLength) || 76;
+            this.options.lineLength = normalizeLineLength(this.options.lineLength);
         }
 
         this.skipStartBytes = Number(this.options.skipStartBytes) || 0;
-        this.limitOutbutBytes = Number(this.options.limitOutbutBytes) || 0;
+        // `limitOutbutBytes` is the name earlier versions read
+        this.limitOutputBytes = Number(this.options.limitOutputBytes || this.options.limitOutbutBytes) || 0;
 
-        // startPadding can be used together with skipStartBytes
+        // encoded characters of the line that is not complete yet. startPadding can be used together
+        // with skipStartBytes
         this._curLine = this.options.startPadding || '';
-        this._remainingBytes = false;
+        // input bytes that do not make up a complete base64 group yet
+        this._remainingBytes = null;
 
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
 
-    _writeChunk(chunk /*, isFinal */) {
+    _writeChunk(chunk) {
         if (this.skipStartBytes) {
             if (chunk.length <= this.skipStartBytes) {
                 this.skipStartBytes -= chunk.length;
                 return;
             }
 
-            chunk = chunk.slice(this.skipStartBytes);
+            chunk = chunk.subarray(this.skipStartBytes);
             this.skipStartBytes = 0;
         }
 
-        if (this.limitOutbutBytes) {
-            if (this.outputBytes + chunk.length <= this.limitOutbutBytes) {
-                // ignore, can use entire chunk
-            } else if (this.outputBytes >= this.limitOutbutBytes) {
+        if (this.limitOutputBytes) {
+            if (this.outputBytes >= this.limitOutputBytes) {
                 // chunks already processed
                 return;
-            } else {
+            }
+            if (this.outputBytes + chunk.length > this.limitOutputBytes) {
                 // use partial chunk
-                chunk = chunk.slice(0, this.limitOutbutBytes - this.outputBytes);
+                chunk = chunk.subarray(0, this.limitOutputBytes - this.outputBytes);
             }
         }
 
@@ -130,12 +198,26 @@ class Encoder extends Transform {
         this.push(chunk);
     }
 
-    _getWrapped(str, isFinal) {
-        str = wrap(str, this.options.lineLength);
-        if (!isFinal && str.length === this.options.lineLength) {
-            str += '\r\n';
+    /**
+     * Emits the encoded characters `b64` that follow the current line, keeping what can not be emitted
+     * yet as the new current line
+     */
+    _emit(b64, final) {
+        let src = Buffer.from(this._curLine + b64, 'latin1');
+        if (!src.length) {
+            return;
+        }
+
+        if (!this.options.lineLength) {
+            this._curLine = '';
+            return this._writeChunk(src);
+        }
+
+        let { output, rest } = wrapBuffer(src, this.options.lineLength, final);
+        this._curLine = rest ? src.toString('latin1', src.length - rest) : '';
+        if (output.length) {
+            this._writeChunk(output);
         }
-        return str;
     }
 
     _transform(chunk, encoding, done) {
@@ -144,58 +226,28 @@ class Encoder extends Transform {
         }
 
         if (!chunk || !chunk.length) {
-            return setImmediate(done);
+            return done();
         }
 
         this.inputBytes += chunk.length;
 
-        if (this._remainingBytes && this._remainingBytes.length) {
+        if (this._remainingBytes) {
             chunk = Buffer.concat([this._remainingBytes, chunk], this._remainingBytes.length + chunk.length);
-            this._remainingBytes = false;
+            this._remainingBytes = null;
         }
 
-        if (chunk.length % 3) {
-            this._remainingBytes = chunk.slice(chunk.length - (chunk.length % 3));
-            chunk = chunk.slice(0, chunk.length - (chunk.length % 3));
-        } else {
-            this._remainingBytes = false;
-        }
-
-        let b64 = this._curLine + encode(chunk);
-
-        if (this.options.lineLength) {
-            b64 = this._getWrapped(b64);
-
-            // remove last line as it is still most probably incomplete
-            let lastLF = b64.lastIndexOf('\n');
-            if (lastLF < 0) {
-                this._curLine = b64;
-                b64 = '';
-            } else if (lastLF === b64.length - 1) {
-                this._curLine = '';
-            } else {
-                this._curLine = b64.substr(lastLF + 1);
-                b64 = b64.substr(0, lastLF + 1);
-            }
+        let extra = chunk.length % 3;
+        if (extra) {
+            this._remainingBytes = chunk.subarray(chunk.length - extra);
+            chunk = chunk.subarray(0, chunk.length - extra);
         }
 
-        if (b64) {
-            this._writeChunk(Buffer.from(b64, 'ascii'), false);
-        }
-
-        setImmediate(done);
+        this._emit(encode(chunk), false);
+        done();
     }
 
     _flush(done) {
-        if (this._remainingBytes && this._remainingBytes.length) {
-            this._curLine += encode(this._remainingBytes);
-        }
-
-        if (this._curLine) {
-            this._curLine = this._getWrapped(this._curLine, true);
-            this._writeChunk(Buffer.from(this._curLine, 'ascii'), true);
-            this._curLine = '';
-        }
+        this._emit(this._remainingBytes ? encode(this._remainingBytes) : '', true);
         done();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "libbase64",
-    "version": "1.3.1",
+    "version": "1.3.2",
     "description": "Encode and decode base64 encoded strings",
     "main": "lib/libbase64.js",
     "scripts": {