@mavogel/awscdk-rootmail 0.1.23 → 0.1.25

package/node_modules/libbase64/{lib → dist/esm}/libbase64.js

@@ -1,38 +1,40 @@
-'use strict';
-
-const { Buffer } = require('node:buffer');
-const stream = require('node:stream');
-const Transform = stream.Transform;
-
+import { Buffer } from 'node:buffer';
+import { Transform } from 'node:stream';
 /**
  * Encodes a Buffer into a base64 encoded string
  *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} base64 encoded string
+ * @param buffer Buffer or unicode string to convert
+ * @returns base64 encoded string
  */
-function encode(buffer) {
+export function encode(buffer) {
     if (typeof buffer === 'string') {
-        buffer = Buffer.from(buffer, 'utf-8');
+        return Buffer.from(buffer, 'utf-8').toString('base64');
+    }
+    if (!Buffer.isBuffer(buffer)) {
+        // a plain Uint8Array has no base64 toString(), it would turn into a list of numbers
+        return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength).toString('base64');
     }
-
     return buffer.toString('base64');
 }
-
 /**
  * Decodes a base64 encoded string to a Buffer object
  *
- * @param {String} str base64 encoded string
- * @returns {Buffer} Decoded value
+ * @param str base64 encoded string
+ * @returns Decoded value
  */
-function decode(str) {
+export 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.
     // Segments are found with indexOf and written into one buffer: splitting the input and
     // keeping a Buffer per segment cost memory per segment, tens of times the input size
     // for a body that pads every line.
     if (typeof str === 'string') {
+        // Buffer reads only the low byte of a character, "Ł" (U+0141) would be decoded as "A".
+        // Characters outside of latin1 are not base64 characters, they are skipped like the rest
+        if (/[^\u0000-\u00ff]/.test(str)) {
+            str = str.replace(/[^\u0000-\u00ff]+/g, '');
+        }
         let padPos = str.indexOf('=');
         if (padPos >= 0 && /[a-zA-Z0-9+/\-_]/.test(str.slice(padPos))) {
             // a segment of n characters decodes to at most n * 3 / 4 bytes
@@ -53,27 +55,25 @@ function decode(str) {
             return Buffer.from(output.subarray(0, length));
         }
     }
-
+    // a Buffer is copied as it is, the encoding argument only applies to strings
     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;
+    let length = Math.floor(Number(lineLength));
+    return Number.isFinite(length) && length >= 1 ? length : 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
+ * @param src Bytes to wrap
+ * @param lineLength Line length
+ * @param final Whether `src` ends the output
+ * @returns The wrapped bytes and the number of trailing bytes not taken
  */
 function wrapBuffer(src, lineLength, final) {
     let lines = Math.ceil(src.length / lineLength);
@@ -81,7 +81,6 @@ function wrapBuffer(src, lineLength, final) {
     // 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) {
@@ -94,39 +93,31 @@ function wrapBuffer(src, lineLength, 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
  *
- * @param {String} str base64 encoded string that might need line wrapping
- * @param {Number} [lineLength=76] Maximum allowed length for a line
- * @returns {String} Soft-wrapped base64 encoded string
+ * @param str base64 encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped base64 encoded string
  */
-function wrap(str, lineLength) {
+export function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = normalizeLineLength(lineLength);
-
-    if (str.length <= lineLength) {
+    let length = normalizeLineLength(lineLength);
+    if (str.length <= length) {
         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 legacyWrap(str, length);
     }
-
-    return wrapBuffer(Buffer.from(str, 'latin1'), lineLength, true).output.toString('latin1');
+    return wrapBuffer(Buffer.from(str, 'latin1'), length, 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
@@ -135,66 +126,49 @@ function legacyWrap(str, lineLength) {
     let result = [];
     let pos = 0;
     let chunkLength = lineLength * 1024;
+    let wrapRegex = new RegExp('.{' + lineLength + '}', 'g');
     while (pos < str.length) {
         let wrappedLines = str
-            .substr(pos, chunkLength)
-            .replace(new RegExp('.{' + lineLength + '}', 'g'), '$&\r\n')
+            .slice(pos, pos + chunkLength)
+            .replace(wrapRegex, '$&\r\n')
             .trim();
         result.push(wrappedLines);
         pos += chunkLength;
     }
-
     return result.join('\r\n').trim();
 }
-
 /**
  * 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 {
+export class Encoder extends Transform {
     constructor(options) {
         super();
-        // init Transform
         this.options = options || {};
-
         if (this.options.lineLength !== false) {
             this.options.lineLength = normalizeLineLength(this.options.lineLength);
         }
-
         this.skipStartBytes = Number(this.options.skipStartBytes) || 0;
-        // `limitOutbutBytes` is the name earlier versions read
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
         this.limitOutputBytes = Number(this.options.limitOutputBytes || this.options.limitOutbutBytes) || 0;
-
-        // encoded characters of the line that is not complete yet. startPadding can be used together
-        // with skipStartBytes
+        // startPadding can be used together with skipStartBytes
         this._curLine = this.options.startPadding || '';
-        // input bytes that do not make up a complete base64 group yet
         this._remainingBytes = null;
-
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
-
+    /** @internal */
     _writeChunk(chunk) {
         if (this.skipStartBytes) {
             if (chunk.length <= this.skipStartBytes) {
                 this.skipStartBytes -= chunk.length;
                 return;
             }
-
             chunk = chunk.subarray(this.skipStartBytes);
             this.skipStartBytes = 0;
         }
-
         if (this.limitOutputBytes) {
             if (this.outputBytes >= this.limitOutputBytes) {
                 // chunks already processed
@@ -205,124 +179,105 @@ class Encoder extends Transform {
                 chunk = chunk.subarray(0, this.limitOutputBytes - this.outputBytes);
             }
         }
-
         this.outputBytes += chunk.length;
         this.push(chunk);
     }
-
     /**
      * Emits the encoded characters `b64` that follow the current line, keeping what can not be emitted
      * yet as the new current line
+     *
+     * @internal
      */
     _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);
         }
     }
-
+    /** @internal */
     _transform(chunk, encoding, done) {
-        if (encoding !== 'buffer') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        if (!chunk || !chunk.length) {
+        let buf = encoding !== 'buffer' ? Buffer.from(chunk, encoding) : chunk;
+        if (!buf.length) {
             return done();
         }
-
-        this.inputBytes += chunk.length;
-
+        this.inputBytes += buf.length;
         if (this._remainingBytes) {
-            chunk = Buffer.concat([this._remainingBytes, chunk], this._remainingBytes.length + chunk.length);
+            buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
             this._remainingBytes = null;
         }
-
-        let extra = chunk.length % 3;
+        let extra = buf.length % 3;
         if (extra) {
-            this._remainingBytes = chunk.subarray(chunk.length - extra);
-            chunk = chunk.subarray(0, chunk.length - extra);
+            this._remainingBytes = buf.subarray(buf.length - extra);
+            buf = buf.subarray(0, buf.length - extra);
         }
-
-        this._emit(encode(chunk), false);
+        this._emit(encode(buf), false);
         done();
     }
-
+    /** @internal */
     _flush(done) {
         this._emit(this._remainingBytes ? encode(this._remainingBytes) : '', true);
+        this._remainingBytes = null;
         done();
     }
 }
-
 /**
  * Creates a transform stream for decoding base64 encoded strings
- *
- * @constructor
- * @param {Object} options Stream options
  */
-class Decoder extends Transform {
+export class Decoder extends Transform {
     constructor(options) {
         super();
-        // init Transform
         this.options = options || {};
         this._curLine = '';
-
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
-
-    _transform(chunk, encoding, done) {
+    /** @internal */
+    _transform(chunk, _encoding, done) {
         if (!chunk || !chunk.length) {
-            return setImmediate(done);
+            return done();
         }
-
         this.inputBytes += chunk.length;
-
-        let b64 = this._curLine + chunk.toString('ascii');
+        // latin1 maps every byte to one character. 'ascii' would clear the high bit of a byte, turning
+        // stray 8-bit bytes into base64 characters instead of skipping them as decode() does
+        let b64 = this._curLine + chunk.toString('latin1');
         this._curLine = '';
-
         if (/[^a-zA-Z0-9+/=]/.test(b64)) {
             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);
+            padded = b64.slice(0, lastPad + 1);
+            b64 = b64.slice(lastPad + 1);
         }
-
         if (b64.length < 4) {
             this._curLine = b64;
             b64 = '';
-        } else if (b64.length % 4) {
-            this._curLine = b64.substr(-b64.length % 4);
-            b64 = b64.substr(0, b64.length - this._curLine.length);
         }
-
+        else if (b64.length % 4) {
+            this._curLine = b64.slice(-(b64.length % 4));
+            b64 = b64.slice(0, b64.length - this._curLine.length);
+        }
         b64 = padded + b64;
-
         if (b64) {
             let buf = decode(b64);
             this.outputBytes += buf.length;
             this.push(buf);
         }
-
-        setImmediate(done);
+        done();
     }
-
+    /** @internal */
     _flush(done) {
         if (this._curLine) {
             let buf = decode(this._curLine);
@@ -330,15 +285,17 @@ class Decoder extends Transform {
             this.push(buf);
             this._curLine = '';
         }
-        setImmediate(done);
+        done();
     }
 }
-
-// expose to the world
-module.exports = {
+// The default export is the same set of members as one object, for `import libbase64 from 'libbase64'`.
+// In the CommonJS build `require('libbase64')` returns the exports object and its `.default` is that
+// object itself, see scripts/build.js
+const libbase64 = {
     encode,
     decode,
     wrap,
     Encoder,
     Decoder
 };
+export default libbase64;

package/node_modules/libbase64/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/node_modules/libbase64/package.json

@@ -1,15 +1,57 @@
 {
     "name": "libbase64",
-    "version": "1.3.3",
+    "version": "1.4.1",
     "description": "Encode and decode base64 encoded strings",
-    "main": "lib/libbase64.js",
+    "type": "module",
+    "main": "./dist/cjs/libbase64.js",
+    "types": "./dist/cjs/libbase64.d.ts",
+    "typesVersions": {
+        "*": {
+            "lib/*": [
+                "dist/cjs/*.d.ts"
+            ]
+        }
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/esm/libbase64.js",
+            "require": "./dist/cjs/libbase64.js"
+        },
+        "./lib/*.js": {
+            "import": "./dist/esm/*.js",
+            "require": "./dist/cjs/*.js"
+        },
+        "./lib/*": {
+            "import": "./dist/esm/*.js",
+            "require": "./dist/cjs/*.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist",
+        "CHANGELOG.md",
+        "SECURITY.md"
+    ],
     "scripts": {
-        "test": "grunt",
-        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
+        "build": "node scripts/build.js",
+        "typecheck": "tsc -p tsconfig.json",
+        "pretest": "npm run build",
+        "test": "node --import tsx --test --test-concurrency=1 $(find test -name \"*-test.ts\")",
+        "pretest:coverage": "npm run build",
+        "test:coverage": "c8 node --import tsx --test --test-concurrency=1 $(find test -name \"*-test.ts\")",
+        "format": "prettier --write \"**/*.{js,cjs,ts,json,md,yml,yaml}\"",
+        "format:check": "prettier --check \"**/*.{js,cjs,ts,json,md,yml,yaml}\"",
+        "lint": "npm run typecheck && eslint .",
+        "lint:fix": "eslint . --fix",
+        "prepare": "npm run build",
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install",
+        "test:fuzz": "FC_NUM_RUNS=20000 node --import tsx --test test/libbase64-property-test.ts",
+        "pretest:bun": "npm run build",
+        "test:bun": "bun test --timeout 60000 $(find ./test -name \"*-test.ts\")"
     },
     "repository": {
         "type": "git",
-        "url": "git://github.com/nodemailer/libbase64.git"
+        "url": "git+https://github.com/nodemailer/libbase64.git"
     },
     "keywords": [
         "base64",
@@ -22,14 +64,18 @@
     },
     "homepage": "https://github.com/nodemailer/libbase64",
     "devDependencies": {
-        "chai": "4.4.1",
-        "eslint-config-nodemailer": "1.2.0",
+        "@types/node": "20.19.43",
+        "c8": "12.0.0",
+        "eslint": "10.13.0",
         "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"
+        "fast-check": "4.10.2",
+        "globals": "17.13.0",
+        "prettier": "3.9.10",
+        "tsx": "4.23.15",
+        "typescript": "6.0.3",
+        "typescript-eslint": "8.71.2"
     },
-    "dependencies": {}
+    "engines": {
+        "node": ">=20.0.0"
+    }
 }

package/node_modules/libmime/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [5.5.1](https://github.com/nodemailer/libmime/compare/v5.5.0...v5.5.1) (2026-10-18)
+
+
+### Bug Fixes
+
+* **deps:** update libbase64 to 1.4.1 and libqp to 3.0.1 ([1d66699](https://github.com/nodemailer/libmime/commit/1d66699e80d953bd1f3279bd332684f4efeb4f71))
+* encode parameter values that look like encoded words ([e85b3fb](https://github.com/nodemailer/libmime/commit/e85b3fbfde3cafc466f0eb93589df5f5c4de53fe))
+
+## [5.5.0](https://github.com/nodemailer/libmime/compare/v5.4.9...v5.5.0) (2026-10-18)
+
+
+### Features
+
+* migrate to TypeScript with ES module and CommonJS builds ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+
+
+### Bug Fixes
+
+* base64 encode the chunks of a Buffer passed to encodeWord only once ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* correct the pyc and ccxml entries of the mime type table and add common modern types ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* drop control characters from header values and parameter names ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* encode control characters and DEL in header parameter values ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* encode unpaired surrogates in header parameters instead of leaving delimiters unencoded ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* keep astral characters outside the emoji block whole in B encoded words ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* mark every parameter continuation that holds percent escapes as encoded ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* quote empty header parameter values ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* refuse every iconv-lite alias of the utf-7, base64 and hex codecs as a charset ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* remove the space stuffing of format=flowed continuation lines ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* space-stuff the continuation lines encodeFlowed creates and trim spaces before hard line breaks ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+* stop splitMimeEncodedString from looping forever on malformed input ([a21884d](https://github.com/nodemailer/libmime/commit/a21884dfbcccc0a1a26300681275ea43fc93970c))
+
 ## [5.4.9](https://github.com/nodemailer/libmime/compare/v5.4.8...v5.4.9) (2026-10-16)