@mavogel/awscdk-rootmail 0.0.19 → 0.0.21

package/node_modules/libmime/node_modules/libqp/lib/libqp.js

@@ -0,0 +1,320 @@
+/* eslint no-useless-escape: 0 */
+
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const stream = require('node:stream');
+const Transform = stream.Transform;
+
+/**
+ * Encodes a Buffer into a Quoted-Printable encoded string
+ *
+ * @param {Buffer} buffer Buffer to convert
+ * @returns {String} Quoted-Printable encoded string
+ */
+function encode(buffer) {
+    if (typeof buffer === 'string') {
+        buffer = Buffer.from(buffer, 'utf-8');
+    }
+
+    // usable characters that do not need encoding
+    let ranges = [
+        // https://tools.ietf.org/html/rfc2045#section-6.7
+        [0x09], // <TAB>
+        [0x0a], // <LF>
+        [0x0d], // <CR>
+        [0x20, 0x3c], // <SP>!"#$%&'()*+,-./0123456789:;
+        [0x3e, 0x7e] // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
+    ];
+    let result = '';
+    let ord;
+
+    for (let i = 0, len = buffer.length; i < len; i++) {
+        ord = buffer[i];
+        // if the char is in allowed range, then keep as is, unless it is a ws in the end of a line
+        if (checkRanges(ord, ranges) && !((ord === 0x20 || ord === 0x09) && (i === len - 1 || buffer[i + 1] === 0x0a || buffer[i + 1] === 0x0d))) {
+            result += String.fromCharCode(ord);
+            continue;
+        }
+        result += '=' + (ord < 0x10 ? '0' : '') + ord.toString(16).toUpperCase();
+    }
+
+    return result;
+}
+
+/**
+ * Decodes a Quoted-Printable encoded string to a Buffer object
+ *
+ * @param {String} str Quoted-Printable encoded string
+ * @returns {Buffer} Decoded value
+ */
+function decode(str) {
+    str = (str || '')
+        .toString()
+        // remove invalid whitespace from the end of lines
+        .replace(/[\t ]+$/gm, '')
+        // remove soft line breaks
+        .replace(/\=(?:\r?\n|$)/g, '');
+
+    let encodedBytesCount = (str.match(/\=[\da-fA-F]{2}/g) || []).length,
+        bufferLength = str.length - encodedBytesCount * 2,
+        chr,
+        hex,
+        buffer = Buffer.alloc(bufferLength),
+        bufferPos = 0;
+
+    for (let i = 0, len = str.length; i < len; i++) {
+        chr = str.charAt(i);
+        if (chr === '=' && (hex = str.substr(i + 1, 2)) && /[\da-fA-F]{2}/.test(hex)) {
+            buffer[bufferPos++] = parseInt(hex, 16);
+            i += 2;
+            continue;
+        }
+        buffer[bufferPos++] = chr.charCodeAt(0);
+    }
+
+    return buffer;
+}
+
+/**
+ * Adds soft line breaks to a Quoted-Printable string
+ *
+ * @param {String} str Quoted-Printable encoded string that might need line wrapping
+ * @param {Number} [lineLength=76] Maximum allowed length for a line
+ * @returns {String} Soft-wrapped Quoted-Printable encoded string
+ */
+function wrap(str, lineLength) {
+    str = (str || '').toString();
+    lineLength = lineLength || 76;
+
+    if (str.length <= lineLength) {
+        return str;
+    }
+
+    let pos = 0,
+        len = str.length,
+        match,
+        code,
+        line,
+        lineMargin = Math.floor(lineLength / 3),
+        result = '';
+
+    // insert soft linebreaks where needed
+    while (pos < len) {
+        line = str.substr(pos, lineLength);
+        if ((match = line.match(/\r\n/))) {
+            line = line.substr(0, match.index + match[0].length);
+            result += line;
+            pos += line.length;
+            continue;
+        }
+
+        if (line.substr(-1) === '\n') {
+            // nothing to change here
+            result += line;
+            pos += line.length;
+            continue;
+        } else if ((match = line.substr(-lineMargin).match(/\n.*?$/))) {
+            // truncate to nearest line break
+            line = line.substr(0, line.length - (match[0].length - 1));
+            result += line;
+            pos += line.length;
+            continue;
+        } else if (line.length > lineLength - lineMargin && (match = line.substr(-lineMargin).match(/[ \t\.,!\?][^ \t\.,!\?]*$/))) {
+            // truncate to nearest space
+            line = line.substr(0, line.length - (match[0].length - 1));
+        } else if (line.match(/\=[\da-f]{0,2}$/i)) {
+            // push incomplete encoding sequences to the next line
+            if ((match = line.match(/\=[\da-f]{0,1}$/i))) {
+                line = line.substr(0, line.length - match[0].length);
+            }
+
+            // ensure that utf-8 sequences are not split
+            while (line.length > 3 && line.length < len - pos && !line.match(/^(?:=[\da-f]{2}){1,4}$/i) && (match = line.match(/\=[\da-f]{2}$/gi))) {
+                code = parseInt(match[0].substr(1, 2), 16);
+                if (code < 128) {
+                    break;
+                }
+
+                line = line.substr(0, line.length - 3);
+
+                if (code >= 0xc0) {
+                    break;
+                }
+            }
+        }
+
+        if (pos + line.length < len && line.substr(-1) !== '\n') {
+            if (line.length === lineLength && line.match(/\=[\da-f]{2}$/i)) {
+                line = line.substr(0, line.length - 3);
+            } else if (line.length === lineLength) {
+                line = line.substr(0, line.length - 1);
+            }
+            pos += line.length;
+            line += '=\r\n';
+        } else {
+            pos += line.length;
+        }
+
+        result += line;
+    }
+
+    return result;
+}
+
+/**
+ * Helper function to check if a number is inside provided ranges
+ *
+ * @param {Number} nr Number to check for
+ * @param {Array} ranges An Array of allowed values
+ * @returns {Boolean} True if the value was found inside allowed ranges, false otherwise
+ */
+function 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;
+}
+
+/**
+ * Creates a transform stream for encoding data to Quoted-Printable encoding
+ *
+ * @constructor
+ * @param {Object} options Stream options
+ * @param {Number} [options.lineLength=76] Maximum lenght for lines, set to false to disable wrapping
+ */
+class Encoder extends Transform {
+    constructor(options) {
+        super();
+
+        // init Transform
+        this.options = options || {};
+
+        if (this.options.lineLength !== false) {
+            this.options.lineLength = this.options.lineLength || 76;
+        }
+
+        this._curLine = '';
+
+        this.inputBytes = 0;
+        this.outputBytes = 0;
+
+        Transform.call(this, this.options);
+    }
+
+    _transform(chunk, encoding, done) {
+        let qp;
+
+        if (encoding !== 'buffer') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+
+        if (!chunk || !chunk.length) {
+            return done();
+        }
+
+        this.inputBytes += chunk.length;
+
+        if (this.options.lineLength) {
+            qp = this._curLine + encode(chunk);
+            qp = wrap(qp, this.options.lineLength);
+            qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
+                this._curLine = lastLine;
+                return lineBreak;
+            });
+
+            if (qp) {
+                this.outputBytes += qp.length;
+                this.push(qp);
+            }
+        } else {
+            qp = encode(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();
+    }
+}
+
+/**
+ * Creates a transform stream for decoding Quoted-Printable encoded strings
+ *
+ * @constructor
+ * @param {Object} options Stream options
+ */
+class Decoder extends Transform {
+    constructor(options) {
+        options = options || {};
+        super(options);
+
+        // init Transform
+        this.options = options;
+        this._curLine = '';
+
+        this.inputBytes = 0;
+        this.outputBytes = 0;
+    }
+
+    _transform(chunk, encoding, done) {
+        let qp, buf;
+
+        chunk = chunk.toString('ascii');
+
+        if (!chunk || !chunk.length) {
+            return done();
+        }
+
+        this.inputBytes += chunk.length;
+
+        qp = this._curLine + chunk;
+        this._curLine = '';
+        qp = qp.replace(/\=[^\n]?$/, lastLine => {
+            this._curLine = lastLine;
+            return '';
+        });
+
+        if (qp) {
+            buf = decode(qp);
+            this.outputBytes += buf.length;
+            this.push(buf);
+        }
+
+        done();
+    }
+
+    _flush(done) {
+        let buf;
+        if (this._curLine) {
+            buf = decode(this._curLine);
+            this.outputBytes += buf.length;
+            this.push(buf);
+        }
+        done();
+    }
+}
+
+// expose to the world
+module.exports = {
+    encode,
+    decode,
+    wrap,
+    Encoder,
+    Decoder
+};

package/node_modules/libmime/node_modules/libqp/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "libqp",
+    "version": "2.1.0",
+    "description": "Encode and decode quoted-printable strings according to rfc2045",
+    "main": "lib/libqp.js",
+    "scripts": {
+        "test": "node --test",
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/nodemailer/libqp.git"
+    },
+    "keywords": [
+        "quoted-printable",
+        "mime"
+    ],
+    "author": "Andris Reinman",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/nodemailer/libqp/issues"
+    },
+    "homepage": "https://github.com/nodemailer/libqp",
+    "devDependencies": {
+        "eslint-config-nodemailer": "1.2.0",
+        "eslint-config-prettier": "9.1.0"
+    }
+}

package/node_modules/libmime/node_modules/libqp/test/libqp-test.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const test = require('node:test');
+const assert = require('node:assert').strict;
+
+const libqp = require('../lib/libqp');
+
+test('Encoding tests', async t => {
+    await t.test('simple string', async () => {
+        const encoded = libqp.encode('tere jõgeva');
+
+        assert.strictEqual(encoded, 'tere j=C3=B5geva');
+    });
+
+    await t.test('stream', async () => {
+        let input = 'tere jõgeva';
+        let encoder = new libqp.Encoder();
+
+        let encoded = await new Promise((resolve, reject) => {
+            let chunks = [];
+            encoder.on('readable', () => {
+                let chunk;
+
+                while ((chunk = encoder.read()) !== null) {
+                    chunks.push(chunk);
+                }
+            });
+            encoder.on('end', () => {
+                resolve(Buffer.concat(chunks).toString());
+            });
+            encoder.on('Error', err => {
+                reject(err);
+            });
+
+            encoder.end(Buffer.from(input));
+        });
+
+        assert.strictEqual(encoded, 'tere j=C3=B5geva');
+    });
+});

package/node_modules/libmime/package.json

@@ -1,12 +1,12 @@
 {
     "name": "libmime",
     "description": "Encode and decode quoted printable and base64 strings",
-    "version": "5.2.1",
-    "main": "lib/libmime",
-    "homepage": "https://github.com/andris9/libmime",
+    "version": "5.3.4",
+    "main": "lib/libmime.js",
+    "homepage": "https://github.com/nodemailer/libmime",
     "repository": {
         "type": "git",
-        "url": "git://github.com/andris9/libmime.git"
+        "url": "git+https://github.com/nodemailer/libmime.git"
     },
     "license": "MIT",
     "keywords": [
@@ -16,22 +16,23 @@
     ],
     "author": "Andris Reinman <andris@kreata.ee>",
     "scripts": {
-        "test": "grunt"
+        "test": "grunt",
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
     },
     "dependencies": {
         "encoding-japanese": "2.0.0",
         "iconv-lite": "0.6.3",
-        "libbase64": "1.2.1",
-        "libqp": "2.0.1"
+        "libbase64": "1.3.0",
+        "libqp": "2.1.0"
     },
     "devDependencies": {
-        "chai": "4.3.7",
+        "chai": "4.4.1",
         "eslint-config-nodemailer": "1.2.0",
-        "eslint-config-prettier": "8.6.0",
-        "grunt": "1.5.3",
+        "eslint-config-prettier": "9.1.0",
+        "grunt": "1.6.1",
         "grunt-cli": "1.4.3",
-        "grunt-eslint": "24.0.1",
+        "grunt-eslint": "24.3.0",
         "grunt-mocha-test": "0.13.3",
-        "mocha": "10.2.0"
+        "mocha": "10.3.0"
     }
 }

package/node_modules/mailparser/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.6.9](https://github.com/nodemailer/mailparser/compare/v3.6.8...v3.6.9) (2024-02-29)
+
+
+### Bug Fixes
+
+* **deps:** Bumped deps ([db842ad](https://github.com/nodemailer/mailparser/commit/db842addd36e2fe94d0c4b466da80719a36f47ac))
+
+## [3.6.8](https://github.com/nodemailer/mailparser/compare/v3.6.7...v3.6.8) (2024-02-29)
+
+
+### Bug Fixes
+
+* **punycode:** Fixes [#355](https://github.com/nodemailer/mailparser/issues/355) Deprecation warning of the punycode module ([#356](https://github.com/nodemailer/mailparser/issues/356)) ([0f35330](https://github.com/nodemailer/mailparser/commit/0f35330c87d715d38e8c853ae6c2f64d098b971d))
+
 ## [3.6.7](https://github.com/nodemailer/mailparser/compare/v3.6.6...v3.6.7) (2024-02-01)
 
 

package/node_modules/mailparser/lib/mail-parser.js

@@ -5,7 +5,7 @@ const libmime = require('libmime');
 const addressparser = require('nodemailer/lib/addressparser');
 const Transform = require('stream').Transform;
 const Splitter = mailsplit.Splitter;
-const punycode = require('punycode');
+const punycode = require('punycode/');
 const FlowedDecoder = require('mailsplit/lib/flowed-decoder');
 const StreamHash = require('./stream-hash');
 const iconv = require('iconv-lite');
@@ -365,6 +365,7 @@ class MailParser extends Transform {
                 case 'reply-to':
                 case 'delivered-to':
                 case 'return-path':
+                case 'disposition-notification-to':
                     value = addressparser(value);
                     this.decodeAddresses(value);
                     value = {
@@ -409,7 +410,8 @@ class MailParser extends Transform {
             'mime-version',
             'content-description',
             'precedence',
-            'errors-to'
+            'errors-to',
+            'disposition-notification-to'
         ];
 
         headers.forEach((value, key) => {

package/node_modules/mailparser/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mailparser",
-    "version": "3.6.7",
+    "version": "3.6.9",
     "description": "Parse e-mails",
     "main": "index.js",
     "scripts": {
@@ -21,15 +21,16 @@
         "he": "1.2.0",
         "html-to-text": "9.0.5",
         "iconv-lite": "0.6.3",
-        "libmime": "5.2.1",
+        "libmime": "5.3.4",
         "linkify-it": "5.0.0",
         "mailsplit": "5.4.0",
-        "nodemailer": "6.9.9",
-        "tlds": "1.248.0"
+        "nodemailer": "6.9.11",
+        "punycode": "2.3.1",
+        "tlds": "1.250.0"
     },
     "devDependencies": {
         "ajv": "8.12.0",
-        "eslint": "8.56.0",
+        "eslint": "8.57.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",
         "grunt": "1.6.1",

package/node_modules/nodemailer/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## [6.9.11](https://github.com/nodemailer/nodemailer/compare/v6.9.10...v6.9.11) (2024-02-29)
+
+
+### Bug Fixes
+
+* **headers:** Ensure that Content-type is the bottom header ([c7cf97e](https://github.com/nodemailer/nodemailer/commit/c7cf97e5ecc83f8eee773359951df995c9945446))
+
+## [6.9.10](https://github.com/nodemailer/nodemailer/compare/v6.9.9...v6.9.10) (2024-02-22)
+
+
+### Bug Fixes
+
+* **data-uri:** Do not use regular expressions for parsing data URI schemes ([12e65e9](https://github.com/nodemailer/nodemailer/commit/12e65e975d80efe6bafe6de4590829b3b5ebb492))
+* **data-uri:** Moved all data-uri regexes to use the non-regex parseDataUri method ([edd5dfe](https://github.com/nodemailer/nodemailer/commit/edd5dfe5ce9b725f8b8ae2830797f65b2a2b0a33))
+
 ## [6.9.9](https://github.com/nodemailer/nodemailer/compare/v6.9.8...v6.9.9) (2024-02-01)
 
 

package/node_modules/nodemailer/lib/mail-composer/index.js

@@ -4,6 +4,7 @@
 
 const MimeNode = require('../mime-node');
 const mimeFuncs = require('../mime-funcs');
+const parseDataURI = require('../shared').parseDataURI;
 
 /**
  * Creates the object for composing a MimeNode instance out from the mail options
@@ -537,12 +538,17 @@ class MailComposer {
      * @return {Object} Parsed element
      */
     _processDataUrl(element) {
-        let parts = (element.path || element.href).match(/^data:((?:[^;]*;){0,20}(?:[^,]*)),(.*)$/i);
-        if (!parts) {
+        let parsedDataUri;
+        if ((element.path || element.href).match(/^data:/)) {
+            parsedDataUri = parseDataURI(element.path || element.href);
+        }
+
+        if (!parsedDataUri) {
             return element;
         }
 
-        element.content = /\bbase64$/i.test(parts[1]) ? Buffer.from(parts[2], 'base64') : Buffer.from(decodeURIComponent(parts[2]));
+        element.content = parsedDataUri.data;
+        element.contentType = element.contentType || parsedDataUri.contentType;
 
         if ('path' in element) {
             element.path = false;
@@ -552,12 +558,6 @@ class MailComposer {
             element.href = false;
         }
 
-        parts[1].split(';').forEach(item => {
-            if (/^\w+\/[^/]+$/i.test(item)) {
-                element.contentType = element.contentType || item.toLowerCase();
-            }
-        });
-
         return element;
     }
 }

package/node_modules/nodemailer/lib/mime-node/index.js

@@ -497,6 +497,15 @@ class MimeNode {
             if (!this.getHeader('MIME-Version')) {
                 this.setHeader('MIME-Version', '1.0');
             }
+
+            // Ensure that Content-Type is the last header for the root node
+            for (let i = this._headers.length - 2; i >= 0; i--) {
+                let header = this._headers[i];
+                if (header.key === 'Content-Type') {
+                    this._headers.splice(i, 1);
+                    this._headers.push(header);
+                }
+            }
         }
 
         this._headers.forEach(header => {

package/node_modules/nodemailer/lib/shared/index.js

@@ -418,6 +418,55 @@ module.exports.callbackPromise = (resolve, reject) =>
         }
     };
 
+module.exports.parseDataURI = uri => {
+    let input = uri;
+    let commaPos = input.indexOf(',');
+    if (!commaPos) {
+        return uri;
+    }
+
+    let data = input.substring(commaPos + 1);
+    let metaStr = input.substring('data:'.length, commaPos);
+
+    let encoding;
+
+    let metaEntries = metaStr.split(';');
+    let lastMetaEntry = metaEntries.length > 1 ? metaEntries[metaEntries.length - 1] : false;
+    if (lastMetaEntry && lastMetaEntry.indexOf('=') < 0) {
+        encoding = lastMetaEntry.toLowerCase();
+        metaEntries.pop();
+    }
+
+    let contentType = metaEntries.shift() || 'application/octet-stream';
+    let params = {};
+    for (let entry of metaEntries) {
+        let sep = entry.indexOf('=');
+        if (sep >= 0) {
+            let key = entry.substring(0, sep);
+            let value = entry.substring(sep + 1);
+            params[key] = value;
+        }
+    }
+
+    switch (encoding) {
+        case 'base64':
+            data = Buffer.from(data, 'base64');
+            break;
+        case 'utf8':
+            data = Buffer.from(data);
+            break;
+        default:
+            try {
+                data = Buffer.from(decodeURIComponent(data));
+            } catch (err) {
+                data = Buffer.from(data);
+            }
+            data = Buffer.from(data);
+    }
+
+    return { data, encoding, contentType, params };
+};
+
 /**
  * Resolves a String or a Buffer value for content value. Useful if the value
  * is a Stream or a file or an URL. If the value is a Stream, overwrites
@@ -470,11 +519,12 @@ module.exports.resolveContent = (data, key, callback) => {
             contentStream = nmfetch(content.path || content.href);
             return resolveStream(contentStream, callback);
         } else if (/^data:/i.test(content.path || content.href)) {
-            let parts = (content.path || content.href).match(/^data:((?:[^;]*;)*(?:[^,]*)),(.*)$/i);
-            if (!parts) {
+            let parsedDataUri = module.exports.parseDataURI(content.path || content.href);
+
+            if (!parsedDataUri || !parsedDataUri.data) {
                 return callback(null, Buffer.from(0));
             }
-            return callback(null, /\bbase64$/i.test(parts[1]) ? Buffer.from(parts[2], 'base64') : Buffer.from(decodeURIComponent(parts[2])));
+            return callback(null, parsedDataUri.data);
         } else if (content.path) {
             return resolveStream(fs.createReadStream(content.path), callback);
         }