@mavogel/awscdk-rootmail 0.1.9 → 0.1.11

package/node_modules/he/src/he.mjs

@@ -0,0 +1,254 @@
+/*! https://mths.be/he by @mathias | MIT license */
+
+import {
+	decodeMap,
+	decodeMapLegacy,
+	decodeMapNumeric,
+	encodeMap,
+	invalidReferenceCodePoints,
+	regexAsciiWhitelist,
+	regexAstralSymbols,
+	regexBmpWhitelist,
+	regexDecode,
+	regexEncodeNonAscii,
+	regexInvalidRawCodePoint,
+} from './data.mjs';
+
+const regexEscape = /["&'<>`]/g;
+const escapeMap = new Map([
+	['"', '&quot;'],
+	['&', '&amp;'],
+	["'", '&#x27;'],
+	['<', '&lt;'],
+	// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+	// following is not strictly necessary unless it’s part of a tag or an
+	// unquoted attribute value. We’re only escaping it to support those
+	// situations, and for XML support.
+	['>', '&gt;'],
+	// In Internet Explorer ≤ 8, the backtick character can be used
+	// to break out of (un)quoted attribute values or HTML comments.
+	// See http://html5sec.org/#102, http://html5sec.org/#108, and
+	// http://html5sec.org/#133.
+	['`', '&#x60;'],
+]);
+
+const regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+
+/*--------------------------------------------------------------------------*/
+
+const has = (object, propertyName) => Object.hasOwn(object, propertyName);
+
+const merge = (options, defaults) => {
+	if (!options) {
+		return defaults;
+	}
+	const result = {};
+	for (const key in defaults) {
+		// A `hasOwnProperty` check is not needed here, since only recognized
+		// option names are used anyway. Any others are ignored.
+		result[key] = has(options, key) ? options[key] : defaults[key];
+	}
+	return result;
+};
+
+const parseError = (message) => {
+	throw new Error(`Parse error: ${message}`);
+};
+
+// Converts a code point to a symbol, applying the HTML spec’s rules for
+// numeric character references.
+const codePointToSymbol = (codePoint, strict) => {
+	if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+		// See issue #4:
+		// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+		// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+		// REPLACEMENT CHARACTER.”
+		if (strict) {
+			parseError('character reference outside the permissible Unicode range');
+		}
+		return '\uFFFD';
+	}
+	if (decodeMapNumeric.has(codePoint)) {
+		if (strict) {
+			parseError('disallowed character reference');
+		}
+		return decodeMapNumeric.get(codePoint);
+	}
+	if (strict && invalidReferenceCodePoints.has(codePoint)) {
+		parseError('disallowed character reference');
+	}
+	return String.fromCodePoint(codePoint);
+};
+
+const hexEscape = (codePoint) => {
+	return `&#x${codePoint.toString(16).toUpperCase()};`;
+};
+
+const decEscape = (codePoint) => {
+	return `&#${codePoint};`;
+};
+
+/*--------------------------------------------------------------------------*/
+
+const encode = (string, options) => {
+	options = merge(options, encode.options);
+	const strict = options.strict;
+	if (strict && regexInvalidRawCodePoint.test(string)) {
+		parseError('forbidden code point');
+	}
+	const encodeEverything = options.encodeEverything;
+	const useNamedReferences = options.useNamedReferences;
+	const allowUnsafeSymbols = options.allowUnsafeSymbols;
+	const escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+	const escapeBmpSymbol = (symbol) => {
+		return escapeCodePoint(symbol.charCodeAt(0));
+	};
+
+	if (encodeEverything) {
+		// Encode ASCII symbols.
+		string = string.replace(regexAsciiWhitelist, (symbol) => {
+			// Use named references if requested & possible.
+			if (useNamedReferences && encodeMap.has(symbol)) {
+				return `&${encodeMap.get(symbol)};`;
+			}
+			return escapeBmpSymbol(symbol);
+		});
+		// Shorten a few escapes that represent two symbols, of which at least one
+		// is within the ASCII range.
+		if (useNamedReferences) {
+			string = string
+				.replace(/&gt;\u20D2/g, '&nvgt;')
+				.replace(/&lt;\u20D2/g, '&nvlt;')
+				.replace(/&#x66;&#x6A;/g, '&fjlig;');
+		}
+		// Encode non-ASCII symbols.
+		if (useNamedReferences) {
+			// Encode non-ASCII symbols that can be replaced with a named reference.
+			string = string.replace(regexEncodeNonAscii, (string) => {
+				// Note: there is no need to check `encodeMap.has(string)` here.
+				return `&${encodeMap.get(string)};`;
+			});
+		}
+		// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+	} else if (useNamedReferences) {
+		// Apply named character references.
+		// Encode `<>"'&` using named character references.
+		if (!allowUnsafeSymbols) {
+			string = string.replace(regexEscape, (string) => {
+				// Note: there is no need to check `encodeMap.has(string)` here.
+				return `&${encodeMap.get(string)};`;
+			});
+		}
+		// Shorten escapes that represent two symbols, of which at least one is
+		// `<>"'&`.
+		string = string
+			.replace(/&gt;\u20D2/g, '&nvgt;')
+			.replace(/&lt;\u20D2/g, '&nvlt;');
+		// Encode non-ASCII symbols that can be replaced with a named reference.
+		string = string.replace(regexEncodeNonAscii, (string) => {
+			// Note: there is no need to check `encodeMap.has(string)` here.
+			return `&${encodeMap.get(string)};`;
+		});
+	} else if (!allowUnsafeSymbols) {
+		// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+		// using named character references.
+		string = string.replace(regexEscape, escapeBmpSymbol);
+	}
+	return (
+		string
+			// Encode astral symbols.
+			.replace(regexAstralSymbols, ($0) => {
+				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+				const high = $0.charCodeAt(0);
+				const low = $0.charCodeAt(1);
+				const codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000;
+				return escapeCodePoint(codePoint);
+			})
+			// Encode any remaining BMP symbols that are not printable ASCII symbols
+			// using a hexadecimal escape.
+			.replace(regexBmpWhitelist, escapeBmpSymbol)
+	);
+};
+// Expose default options (so they can be overridden globally).
+encode.options = {
+	allowUnsafeSymbols: false,
+	encodeEverything: false,
+	strict: false,
+	useNamedReferences: false,
+	decimal: false,
+};
+
+const decode = (html, options) => {
+	options = merge(options, decode.options);
+	const strict = options.strict;
+	if (strict && regexInvalidEntity.test(html)) {
+		parseError('malformed character reference');
+	}
+	return html.replace(regexDecode, ($0, $1, $2, $3, $4, $5, $6, $7) => {
+		if ($1) {
+			// Note: there is no need to check `decodeMap.has($1)`.
+			return decodeMap.get($1);
+		}
+
+		if ($2) {
+			// Decode named character references without trailing `;`, e.g. `&amp`.
+			// This is only a parse error if it gets converted to `&`, or if it is
+			// followed by `=` in an attribute context.
+			const reference = $2;
+			const next = $3;
+			if (next && options.isAttributeValue) {
+				if (strict && next == '=') {
+					parseError('`&` did not start a character reference');
+				}
+				return $0;
+			}
+			if (strict) {
+				parseError(
+					'named character reference was not terminated by a semicolon',
+				);
+			}
+			// Note: there is no need to check `decodeMapLegacy.has(reference)`.
+			return decodeMapLegacy.get(reference) + (next || '');
+		}
+
+		if ($4) {
+			// Decode decimal escapes, e.g. `&#119558;`.
+			const semicolon = $5;
+			if (strict && !semicolon) {
+				parseError('character reference was not terminated by a semicolon');
+			}
+			return codePointToSymbol(parseInt($4, 10), strict);
+		}
+
+		if ($6) {
+			// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+			const semicolon = $7;
+			if (strict && !semicolon) {
+				parseError('character reference was not terminated by a semicolon');
+			}
+			return codePointToSymbol(parseInt($6, 16), strict);
+		}
+
+		// If we’re still here, the ambiguous ampersand group matched; it’s an
+		// ambiguous ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+		if (strict) {
+			parseError('named character reference was not recognized');
+		}
+		return $0;
+	});
+};
+// Expose default options (so they can be overridden globally).
+decode.options = {
+	isAttributeValue: false,
+	strict: false,
+};
+
+const escape = (string) => {
+	return string.replace(regexEscape, ($0) => {
+		// Note: there is no need to check `escapeMap.has($0)` here.
+		return escapeMap.get($0);
+	});
+};
+
+export { decode, encode, escape, decode as unescape };

package/node_modules/libbase64/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/node_modules/libbase64/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/node_modules/libbase64/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": {

package/node_modules/libmime/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [5.4.7](https://github.com/nodemailer/libmime/compare/v5.4.6...v5.4.7) (2026-10-04)
+
+
+### Bug Fixes
+
+* **deps:** update libbase64 to 1.3.2 ([889e761](https://github.com/nodemailer/libmime/commit/889e761b34d3d6ce46b80b9a0ab5f92097b8d41f))
+
 ## [5.4.6](https://github.com/nodemailer/libmime/compare/v5.4.5...v5.4.6) (2026-09-28)
 
 

package/node_modules/libmime/package.json

@@ -1,7 +1,7 @@
 {
     "name": "libmime",
     "description": "Encode and decode quoted printable and base64 strings",
-    "version": "5.4.6",
+    "version": "5.4.7",
     "main": "lib/libmime.js",
     "files": [
         "lib",
@@ -26,7 +26,7 @@
     "dependencies": {
         "encoding-japanese": "2.4.0",
         "iconv-lite": "0.7.3",
-        "libbase64": "1.3.1",
+        "libbase64": "1.3.2",
         "libqp": "2.1.2"
     },
     "devDependencies": {

package/node_modules/mailparser/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "3.9.34"
+    ".": "3.9.35"
 }

package/node_modules/mailparser/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [3.9.35](https://github.com/nodemailer/mailparser/compare/v3.9.34...v3.9.35) (2026-10-04)
+
+
+### Bug Fixes
+
+* **deps:** update libmime to 5.4.7, mailsplit to 5.4.20 and he to 2.0.0 ([c1d68c2](https://github.com/nodemailer/mailparser/commit/c1d68c2582a01a284afd6b86a8782bdfa492afda))
+
 ## [3.9.34](https://github.com/nodemailer/mailparser/compare/v3.9.33...v3.9.34) (2026-10-03)
 
 

package/node_modules/mailparser/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mailparser",
-    "version": "3.9.34",
+    "version": "3.9.35",
     "description": "Parse e-mails",
     "main": "index.js",
     "scripts": {
@@ -19,12 +19,12 @@
     "license": "MIT",
     "dependencies": {
         "encoding-japanese": "2.4.0",
-        "he": "1.2.0",
+        "he": "2.0.0",
         "html-to-text": "10.0.1",
         "iconv-lite": "0.7.3",
-        "libmime": "5.4.6",
+        "libmime": "5.4.7",
         "linkify-it": "5.0.2",
-        "@zone-eu/mailsplit": "5.4.19",
+        "@zone-eu/mailsplit": "5.4.20",
         "nodemailer": "10.0.14",
         "punycode.js": "2.3.1",
         "tlds": "1.261.0"

package/package.json

@@ -86,7 +86,7 @@
     "@mavogel/mvc-projen": "^0.0.50",
     "cdk-nag": "^3.0.1",
     "constructs": "^10.5.1",
-    "mailparser": "^3.9.34",
+    "mailparser": "^3.9.35",
     "uuid": "^14.0.2"
   },
   "bundledDependencies": [
@@ -121,9 +121,30 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.9",
+  "version": "0.1.11",
   "jest": {
     "coverageProvider": "v8",
+    "transformIgnorePatterns": [
+      "/node_modules/(?!he/)"
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "test/tsconfig.json"
+        }
+      ],
+      "^.+\\.mjs$": [
+        "ts-jest",
+        {
+          "tsconfig": {
+            "allowJs": true,
+            "module": "commonjs",
+            "esModuleInterop": true
+          }
+        }
+      ]
+    },
     "testMatch": [
       "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
       "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
@@ -157,15 +178,7 @@
           "outputDirectory": "test-reports"
         }
       ]
-    ],
-    "transform": {
-      "^.+\\.[t]sx?$": [
-        "ts-jest",
-        {
-          "tsconfig": "test/tsconfig.json"
-        }
-      ]
-    }
+    ]
   },
   "types": "lib/index.d.ts",
   "jsii": {

package/renovate.json5

@@ -48,6 +48,7 @@
     "constructs",
     "cdk-nag",
     "aws-cdk",
+    "@mavogel/mvc-projen",
     "actions/checkout",
     "actions/setup-node",
     "actions/upload-artifact",