mailparser 3.9.39 → 3.9.41

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "3.9.39"
+    ".": "3.9.41"
 }

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [3.9.41](https://github.com/nodemailer/mailparser/compare/v3.9.40...v3.9.41) (2026-10-18)
+
+
+### Bug Fixes
+
+* bump @zone-eu/mailsplit to 5.4.24 ([eb4b34b](https://github.com/nodemailer/mailparser/commit/eb4b34b04b18de974a3bd61c295d2abca1eb0d69))
+
+## [3.9.40](https://github.com/nodemailer/mailparser/compare/v3.9.39...v3.9.40) (2026-10-16)
+
+
+### Bug Fixes
+
+* bump @zone-eu/mailsplit to 5.4.23 ([32adf4f](https://github.com/nodemailer/mailparser/commit/32adf4f9b7d10a95f98359de7476ebb7fe526cf0))
+* bump libmime to 5.4.9 and nodemailer to 10.1.2 ([a928892](https://github.com/nodemailer/mailparser/commit/a92889221c11eb81b06472f911672b71c288c4ef))
+* keep the message when its HTML can not be converted to text, and never turn a decoded display name into an address ([0d234fd](https://github.com/nodemailer/mailparser/commit/0d234fd3ab1207a617e3682b27c72f4902d76936))
+
 ## [3.9.39](https://github.com/nodemailer/mailparser/compare/v3.9.38...v3.9.39) (2026-10-14)
 
 

package/README.md

@@ -28,7 +28,8 @@ See [mailparser homepage](https://nodemailer.com/extras/mailparser/) for documen
 ### Limits
 
 - `simpleParser` replaces `cid:` image references in the HTML with `data:` URLs. The total length of the URLs written into the HTML is capped by the `maxInlinedImagesSize` option (default 20 MB, counted in characters of the inserted URLs). References past the cap stay as `cid:` links. The same cap applies to URLs returned from a custom `updateImageLinks()` callback.
-- `simpleParser` calls its callback, or settles its promise, exactly once. When `MailParser` reports a non-fatal error (for example HTML longer than `maxHtmlLengthToParse`), that error is what the caller receives. `MailParser` itself still emits the `'error'` event and then finishes parsing.
+- `simpleParser` calls its callback, or settles its promise, exactly once. When `MailParser` reports a non-fatal error and then finishes parsing, that error is what the caller receives.
+- HTML that can not be converted to text (longer than `maxHtmlLengthToParse`, nested deeper than 1000 levels, or rejected by html-to-text) does not fail the message. `text` is empty, `html` is kept, and the reason is set as `textConversionError` on the result (and on the `text` object `MailParser` emits).
 
 ### License
 

package/lib/mail-parser.js

@@ -82,27 +82,121 @@ linkify.add('@', {
     }
 });
 
-// Linear equivalent of /<[^<>]+@[^<>]+>/.test(str). The regex backtracks
-// quadratically on a long run of @ characters after a lone <, and the input is a
-// decoded encoded-word bounded only by the header size limit.
-function hasBracketedAddress(str) {
-    let start = -1;
-    // first @ after the current < that has at least one character before it
-    let at = -1;
-    for (let i = 0, len = str.length; i < len; i++) {
-        let chr = str.charAt(i);
-        if (chr === '<') {
-            start = i;
-            at = -1;
-        } else if (chr === '>') {
-            if (start >= 0 && at >= 0 && at < i - 1) {
-                return true;
+// Lists the parameters a header value gives in RFC 2231 form (name*=, name*0= or
+// name*0*=). libmime decodes those while parsing the header, so the result must not go
+// through decodeWords as well: filename*=utf-8''a%3D%3Futf-8%3FQ%3F%3D2Eexe%3F%3D would
+// otherwise come out as "a.exe" while a parser that decodes once sees the encoded word.
+function rfc2231ParamNames(value) {
+    let names = new Set();
+    let quote = false;
+    let escaped = false;
+    let start = 0;
+
+    let addSegment = end => {
+        let segment = value.substring(start, end);
+        let eq = segment.indexOf('=');
+        if (eq < 0) {
+            return;
+        }
+        let match = segment
+            .substring(0, eq)
+            .trim()
+            .toLowerCase()
+            .match(/^(.+?)\*(\d+\*?)?$/);
+        if (match) {
+            names.add(match[1]);
+        }
+    };
+
+    for (let i = 0; i < value.length; i++) {
+        let chr = value.charAt(i);
+        if (escaped) {
+            escaped = false;
+        } else if (chr === '\\') {
+            escaped = true;
+        } else if (chr === '"') {
+            quote = !quote;
+        } else if (chr === ';' && !quote) {
+            addSegment(i);
+            start = i + 1;
+        }
+    }
+    addSegment(value.length);
+
+    return names;
+}
+
+// Deepest element nesting html-to-text is asked to convert. htmlparser2 keeps its open
+// element stack at the front of an array, so parsing alone is quadratic in the nesting
+// depth (200k nested <b> took 9 s), and html-to-text's recursive walk overflows the call
+// stack at about 2000 levels. Real markup stays far below this: Chrome's own parser
+// flattens anything nested deeper than 512 levels.
+const MAX_HTML_NESTING_DEPTH = 1000;
+
+// Elements that never hold content, so a start tag does not open a level
+const HTML_VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+
+// Elements the HTML parser closes implicitly when a sibling opens (li after li, td after
+// td, p after p), so an unclosed run of them does not nest. They are left out of the depth
+// count: a report with thousands of unclosed table cells is sloppy but common markup
+const HTML_IMPLIED_END_ELEMENTS = new Set(['p', 'li', 'dt', 'dd', 'option', 'optgroup', 'tr', 'td', 'th', 'thead', 'tbody', 'tfoot', 'rt', 'rp']);
+
+function isTagNameChar(code) {
+    return (
+        (code >= 0x61 && code <= 0x7a) || (code >= 0x41 && code <= 0x5a) || (code >= 0x30 && code <= 0x39) || code === 0x2d || code === 0x3a || code === 0x5f
+    );
+}
+
+// Reports whether `html` nests elements deeper than `maxDepth`, in one linear pass that
+// follows what htmlparser2 builds: a start tag opens an element (a trailing "/" does not
+// close it in HTML mode), an end tag closes down to the nearest open element of that name
+// and is ignored otherwise, comments are skipped. Returns as soon as the limit is crossed.
+function exceedsHtmlNestingDepth(html, maxDepth) {
+    let stack = [];
+    let open = new Map(); // element name -> how many of them are on the stack
+    let len = html.length;
+    let i = html.indexOf('<');
+    while (i >= 0) {
+        let pos = i + 1;
+        if (html.startsWith('!--', pos)) {
+            let end = html.indexOf('-->', pos + 3);
+            i = end < 0 ? -1 : html.indexOf('<', end + 3);
+            continue;
+        }
+        let closing = html.charCodeAt(pos) === 0x2f; // "/"
+        if (closing) {
+            pos++;
+        }
+        let nameStart = pos;
+        while (pos < len && isTagNameChar(html.charCodeAt(pos))) {
+            pos++;
+        }
+        if (pos === nameStart) {
+            // not a tag, "<" is text here
+            i = html.indexOf('<', pos);
+            continue;
+        }
+        let name = html.slice(nameStart, pos).toLowerCase();
+        let end = html.indexOf('>', pos);
+        if (end < 0) {
+            break;
+        }
+        if (!HTML_VOID_ELEMENTS.has(name) && !HTML_IMPLIED_END_ELEMENTS.has(name)) {
+            if (!closing) {
+                stack.push(name);
+                open.set(name, (open.get(name) || 0) + 1);
+                if (stack.length > maxDepth) {
+                    return true;
+                }
+            } else if (open.get(name)) {
+                let popped;
+                do {
+                    popped = stack.pop();
+                    open.set(popped, open.get(popped) - 1);
+                } while (popped !== name);
             }
-            start = -1;
-            at = -1;
-        } else if (chr === '@' && start >= 0 && at < 0 && i > start + 1) {
-            at = i;
         }
+        i = html.indexOf('<', end + 1);
     }
     return false;
 }
@@ -379,12 +473,17 @@ class MailParser extends Transform {
             switch (key) {
                 case 'content-type':
                 case 'content-disposition':
-                case 'dkim-signature':
+                case 'dkim-signature': {
+                    // a parameter given in RFC 2231 form is decoded by parseHeaderValue already
+                    let rfc2231 = rfc2231ParamNames(value);
                     value = this.libmime.parseHeaderValue(value);
                     if (value.value) {
                         value.value = this.libmime.decodeWords(value.value);
                     }
                     Object.keys((value && value.params) || {}).forEach(key => {
+                        if (rfc2231.has(key)) {
+                            return;
+                        }
                         try {
                             value.params[key] = this.libmime.decodeWords(value.params[key]);
                         } catch (E) {
@@ -392,6 +491,7 @@ class MailParser extends Transform {
                         }
                     });
                     break;
+                }
                 case 'date': {
                     let dateValue = new Date(value);
                     if (isNaN(dateValue)) {
@@ -464,7 +564,12 @@ class MailParser extends Transform {
                 if (!headers.has(key)) {
                     headers.set(key, [].concat(value || []));
                 } else if (Array.isArray(value)) {
-                    headers.set(key, headers.get(key).concat(value));
+                    // appended in place: rebuilding the list with concat for every repeated
+                    // header was quadratic in the number of References lines
+                    let list = headers.get(key);
+                    for (let entry of value) {
+                        list.push(entry);
+                    }
                 } else {
                     headers.get(key).push(value);
                 }
@@ -495,7 +600,9 @@ class MailParser extends Transform {
         headers.forEach((value, key) => {
             if (Array.isArray(value)) {
                 if (singleKeys.includes(key) && value.length) {
-                    headers.set(key, value[value.length - 1]);
+                    // the first occurrence: the one mailsplit built the MIME structure from,
+                    // and the one mail clients display when the header is duplicated
+                    headers.set(key, value[0]);
                 } else if (value.length === 1) {
                     headers.set(key, value[0]);
                 }
@@ -593,38 +700,14 @@ class MailParser extends Transform {
     }
 
     decodeAddresses(addresses) {
-        let processedAddress = new WeakSet();
         for (let i = 0; i < addresses.length; i++) {
             let address = addresses[i];
             address.name = (address.name || '').toString().trim();
 
-            if (!address.address && /^(=\?([^?]+)\?[Bb]\?[^?]*\?=)(\s*=\?([^?]+)\?[Bb]\?[^?]*\?=)*$/.test(address.name) && !processedAddress.has(address)) {
-                let decoded = this.libmime.decodeWords(address.name);
-                // Security fix: only re-parse if decoded text contains angle-bracket-delimited
-                // addresses (e.g. "Name <user@domain>"). Bare decoded text like "attacker@evil.com"
-                // must not be re-interpreted as an address -- RFC 2047 Section 5 prohibits
-                // encoded-words in addr-spec, and re-parsing fabricates addresses not present
-                // in the original header.
-                if (hasBracketedAddress(decoded)) {
-                    let parsed = addressparser(decoded);
-                    if (parsed.length) {
-                        parsed.forEach(entry => {
-                            processedAddress.add(entry);
-                            addresses.push(entry);
-                        });
-                    }
-
-                    // remove current element
-                    addresses.splice(i, 1);
-                    i--;
-                    continue;
-                } else {
-                    // Treat decoded content as display name only
-                    address.name = decoded;
-                    continue;
-                }
-            }
-
+            // An encoded word decodes into the display name and nothing else, whatever it
+            // decodes to. RFC 2047 section 5 keeps encoded words out of the addr-spec, so a
+            // name that decodes to "CEO" <ceo@bank.com> is still only a name: parsing it
+            // again would report an address the header never carried
             if (address.name) {
                 try {
                     address.name = this.libmime.decodeWords(address.name);
@@ -762,6 +845,7 @@ class MailParser extends Transform {
     getTextContent() {
         let text = [];
         let html = [];
+        let textConversionError = null;
         let processNode = (alternative, level, node) => {
             if (node.showMeta) {
                 let meta = ['From', 'Subject', 'Date', 'To', 'Cc', 'Bcc']
@@ -845,27 +929,34 @@ class MailParser extends Transform {
                         html.push(this.textToHtml(node.textContent));
                     }
                 } else if (node.contentType === 'text/html') {
-                    let failedToParseHtml = false;
                     if ((!alternative && this.hasText) || (node.root && !this.hasText)) {
                         if (this.options.skipHtmlToText) {
                             text.push('');
-                        } else if (node.textContent.length > this.options.maxHtmlLengthToParse) {
-                            this.emit('error', new Error(`HTML too long for parsing ${node.textContent.length} bytes`));
-                            text.push('Invalid HTML content (too long)');
-                            failedToParseHtml = true;
                         } else {
-                            try {
-                                text.push(htmlToText(node.textContent));
-                            } catch (err) {
-                                this.emit('error', new Error('Failed to parse HTML'));
-                                text.push('Invalid HTML content');
-                                failedToParseHtml = true;
+                            // HTML that can not be converted is no reason to lose the message:
+                            // the text stays empty, the HTML is kept and the reason travels with
+                            // the result as textConversionError. An 'error' event here used to
+                            // reject the whole simpleParser() promise, headers and attachments
+                            // included, after burning the CPU the conversion attempt took
+                            let err = null;
+                            if (node.textContent.length > this.options.maxHtmlLengthToParse) {
+                                err = new Error(`HTML too long for parsing ${node.textContent.length} bytes`);
+                            } else if (exceedsHtmlNestingDepth(node.textContent, MAX_HTML_NESTING_DEPTH)) {
+                                err = new Error(`HTML nested deeper than ${MAX_HTML_NESTING_DEPTH} levels`);
+                            } else {
+                                try {
+                                    text.push(htmlToText(node.textContent, { limits: { maxDepth: MAX_HTML_NESTING_DEPTH } }));
+                                } catch (cause) {
+                                    err = new Error('Failed to parse HTML', { cause });
+                                }
+                            }
+                            if (err) {
+                                text.push('');
+                                textConversionError = textConversionError || err;
                             }
                         }
                     }
-                    if (!failedToParseHtml) {
-                        html.push(node.textContent);
-                    }
+                    html.push(node.textContent);
                 }
             }
             alternative = alternative || node.contentType === 'multipart/alternative';
@@ -888,6 +979,9 @@ class MailParser extends Transform {
             this.text = response.text = text.join('\n');
             this.textAsHtml = response.textAsHtml = text.map(part => this.textToHtml(part)).join('<br/>\n');
         }
+        if (textConversionError) {
+            response.textConversionError = textConversionError;
+        }
         return response;
     }
 
@@ -1147,7 +1241,8 @@ class MailParser extends Transform {
                 .map(address => {
                     let str = '';
                     if (address.name) {
-                        str += `"${address.name}"` + (address.group ? ': ' : '');
+                        // a quoted-string, so a quote or backslash inside the name is escaped
+                        str += `"${address.name.replace(/["\\]/g, '\\$&')}"` + (address.group ? ': ' : '');
                     }
                     if (address.address) {
                         let link = address.address;

package/lib/simple-parser.js

@@ -19,8 +19,8 @@ module.exports = (input, options, callback) => {
         });
     }
 
-    // MailParser may emit a non-fatal 'error' (eg. HTML too long to convert to text) and
-    // still reach 'end', so settle only once: the first error or the result wins
+    // MailParser may emit a non-fatal 'error' and still reach 'end', so settle only once:
+    // the first error or the result wins
     let settled = false;
     let settle = callback;
     callback = (...args) => {
@@ -62,7 +62,7 @@ module.exports = (input, options, callback) => {
 
         if (data.type === 'text') {
             Object.keys(data).forEach(key => {
-                if (['text', 'html', 'textAsHtml'].includes(key)) {
+                if (['text', 'html', 'textAsHtml', 'textConversionError'].includes(key)) {
                     mail[key] = data[key];
                 }
             });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mailparser",
-    "version": "3.9.39",
+    "version": "3.9.41",
     "description": "Parse e-mails",
     "main": "index.js",
     "scripts": {
@@ -18,14 +18,14 @@
     ],
     "license": "MIT",
     "dependencies": {
+        "@zone-eu/mailsplit": "5.4.24",
         "encoding-japanese": "2.4.0",
         "he": "1.2.0",
         "html-to-text": "10.0.1",
         "iconv-lite": "0.7.3",
-        "libmime": "5.4.8",
+        "libmime": "5.4.9",
         "linkify-it": "5.0.2",
-        "@zone-eu/mailsplit": "5.4.21",
-        "nodemailer": "10.1.1",
+        "nodemailer": "10.1.2",
         "punycode.js": "2.3.1",
         "tlds": "1.261.0"
     },