libbase64 1.3.0 → 1.3.2

package/.github/workflows/release.yaml

@@ -2,6 +2,9 @@ on:
     push:
         branches:
             - master
+    # Manual run: publish the version currently on master (used when a release was cut
+    # but the publish step failed)
+    workflow_dispatch:
 
 permissions:
     contents: write
@@ -15,23 +18,22 @@ jobs:
         steps:
             - uses: google-github-actions/release-please-action@v3
               id: release
+              if: ${{ github.event_name == 'push' }}
               with:
                   release-type: node
                   package-name: ${{vars.NPM_MODULE_NAME}}
                   pull-request-title-pattern: 'chore${scope}: release ${version} [skip-ci]'
-            # The logic below handles the npm publication:
+            # The logic below handles the npm publication through npm trusted publishing
+            # (OIDC, no token secret): it runs when a new release is created, or on a
+            # manual dispatch.
             - uses: actions/checkout@v4
-              # these if statements ensure that a publication only occurs when
-              # a new release is created:
-              if: ${{ steps.release.outputs.release_created }}
+              if: ${{ steps.release.outputs.release_created || github.event_name == 'workflow_dispatch' }}
             - uses: actions/setup-node@v4
               with:
-                  node-version: 20
+                  node-version: 24
                   registry-url: 'https://registry.npmjs.org'
-              if: ${{ steps.release.outputs.release_created }}
+              if: ${{ steps.release.outputs.release_created || github.event_name == 'workflow_dispatch' }}
             - run: npm ci
-              if: ${{ steps.release.outputs.release_created }}
+              if: ${{ steps.release.outputs.release_created || github.event_name == 'workflow_dispatch' }}
             - run: npm publish --provenance --access public
-              env:
-                  NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-              if: ${{ steps.release.outputs.release_created }}
+              if: ${{ steps.release.outputs.release_created || github.event_name == 'workflow_dispatch' }}

package/.ncurc.js

@@ -1,7 +1,13 @@
 module.exports = {
     upgrade: true,
     reject: [
+        // 12 is esm only ("type": "module"), and grunt-mocha-test require()s it as a
+        // constructor - "Mocha is not a constructor". Node 24 hides this through
+        // require(esm); CI on Node 22 does not. Lift it when the runner drops grunt.
+        'mocha',
         // 5x is esm only
-        'chai'
+        'chai',
+        // api changes in newer eslint
+        'grunt-eslint'
     ]
 };

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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)
+
+
+### Bug Fixes
+
+* **decoder:** decode every padded segment instead of stopping at the first padding ([d9ba154](https://github.com/nodemailer/libbase64/commit/d9ba154ba13e45338936a55acec417dfb6ae2e52))
+
 ## [1.3.0](https://github.com/nodemailer/libbase64/compare/v1.2.1...v1.3.0) (2024-02-23)
 
 

package/lib/libbase64.js

@@ -26,9 +26,71 @@ function encode(buffer) {
  */
 function decode(str) {
     str = str || '';
+
+    // Buffer.from() stops decoding at the first padding char, so input made of several
+    // padded segments (eg. every line padded on its own) is decoded segment by segment
+    if (typeof str === 'string') {
+        let padPos = str.indexOf('=');
+        if (padPos >= 0 && /[a-zA-Z0-9+/\-_]/.test(str.substr(padPos))) {
+            let parts = [];
+            for (let segment of str.split(/[=]+/)) {
+                if (segment) {
+                    parts.push(Buffer.from(segment, 'base64'));
+                }
+            }
+            return Buffer.concat(parts);
+        }
+    }
+
     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
  *
@@ -38,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;
@@ -62,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) {
@@ -73,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);
             }
         }
 
@@ -114,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) {
@@ -128,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;
-        }
-
-        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);
-            }
+            this._remainingBytes = null;
         }
 
-        if (b64) {
-            this._writeChunk(Buffer.from(b64, 'ascii'), false);
+        let extra = chunk.length % 3;
+        if (extra) {
+            this._remainingBytes = chunk.subarray(chunk.length - extra);
+            chunk = chunk.subarray(0, chunk.length - extra);
         }
 
-        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();
     }
 }
@@ -215,6 +283,15 @@ class Decoder extends Transform {
             b64 = b64.replace(/[^a-zA-Z0-9+/=]/g, '');
         }
 
+        // everything up to the last padding char ends in complete segments, quartets are
+        // only counted from there on as a padding run restarts the quartet alignment
+        let padded = '';
+        let lastPad = b64.lastIndexOf('=');
+        if (lastPad >= 0) {
+            padded = b64.substr(0, lastPad + 1);
+            b64 = b64.substr(lastPad + 1);
+        }
+
         if (b64.length < 4) {
             this._curLine = b64;
             b64 = '';
@@ -223,6 +300,8 @@ class Decoder extends Transform {
             b64 = b64.substr(0, b64.length - this._curLine.length);
         }
 
+        b64 = padded + b64;
+
         if (b64) {
             let buf = decode(b64);
             this.outputBytes += buf.length;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "libbase64",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "description": "Encode and decode base64 encoded strings",
     "main": "lib/libbase64.js",
     "scripts": {
@@ -24,9 +24,9 @@
     "devDependencies": {
         "chai": "4.4.1",
         "eslint-config-nodemailer": "1.2.0",
-        "eslint-config-prettier": "9.1.0",
-        "grunt": "1.6.1",
-        "grunt-cli": "1.4.3",
+        "eslint-config-prettier": "10.1.8",
+        "grunt": "1.6.3",
+        "grunt-cli": "1.5.0",
         "grunt-eslint": "24.3.0",
         "grunt-mocha-test": "0.13.3",
         "mocha": "10.3.0"