@limetech/lime-elements 40.6.0 → 40.6.1

package/dist/esm/limel-file-viewer.entry.js

@@ -1,8 +1,8 @@
-import { r as registerInstance, c as createEvent, h, F as Fragment, a as getElement } from './index-Bnc9lzk2.js';
-import { t as translate } from './translations-DMtX4tTX.js';
+import { r as registerInstance, c as createEvent, h, F as Fragment, a as getElement } from './index-BU9IJqli.js';
+import { t as translations } from './translations-Y4i8PVc9.js';
 import { d as defaultSchema, u as unified, r as rehypeParse, a as rehypeSanitize, v as visit, b as rehypeStringify } from './index-BN64nlbO.js';
-import { I as ImageTemplate } from './image.template-wqMwmOF-.js';
-import './language-C3hECvXE.js';
+import { I as ImageTemplate } from './image.template-BGjw97m_.js';
+import './language-ChagAaNf.js';
 import './_commonjsHelpers-B85MJLTf.js';
 
 /**
@@ -123,15 +123,12 @@ class Fullscreen {
 }
 
 const textEncoder = new TextEncoder();
-
 const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
 // Use a lookup table to find the index.
 const base64Lookup = new Uint8Array(256);
 for (let i = 0; i < base64Chars.length; i++) {
     base64Lookup[base64Chars.charCodeAt(i)] = i;
 }
-
 function decodeBase64(base64) {
     // Padding carries no data, so the byte count comes from the payload alone. Sizing the
     // buffer from the raw length instead treated '=' as a data character and left the
@@ -140,26 +137,20 @@ function decodeBase64(base64) {
     while (len > 0 && base64.charAt(len - 1) === '=') {
         len--;
     }
-
     // A remainder of one character cannot encode a byte, it is a truncated group
     if (len % 4 === 1) {
         len--;
     }
-
     const remainder = len % 4;
     const bufferLength = Math.floor(len / 4) * 3 + (remainder ? remainder - 1 : 0);
-
     const arrayBuffer = new ArrayBuffer(bufferLength);
     const bytes = new Uint8Array(arrayBuffer);
-
     let p = 0;
-
     for (let i = 0; i < len; i += 4) {
         let encoded1 = base64Lookup[base64.charCodeAt(i)];
         let encoded2 = base64Lookup[base64.charCodeAt(i + 1)];
         let encoded3 = base64Lookup[base64.charCodeAt(i + 2)];
         let encoded4 = base64Lookup[base64.charCodeAt(i + 3)];
-
         bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
         if (p < bufferLength) {
             bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
@@ -168,10 +159,8 @@ function decodeBase64(base64) {
             bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
         }
     }
-
     return arrayBuffer;
 }
-
 // Charset labels the WHATWG Encoding Standard does not list, but that name an encoding
 // TextDecoder can decode. Without an entry the TextDecoder constructor throws and
 // getDecoder falls back to windows-1252, turning the body into mojibake with nothing to
@@ -185,14 +174,12 @@ const charsetAliases = new Map([
     // Hebrew. The logical and explicit ordering variants share the iso-8859-8 index.
     ['iso88598i', 'iso-8859-8'],
     ['iso88598e', 'iso-8859-8'],
-
     // Japanese. WHATWG shift_jis is the Windows-31J index, so cp932 text decodes
     // identically, including the NEC and IBM extension rows.
     ['shiftjis', 'shift_jis'],
     ['windows31j', 'shift_jis'],
     ['mskanji', 'shift_jis'],
     ['eucjp', 'euc-jp'],
-
     // ISO-2022-JP, including the -1 / -2 supersets. Escape sequences outside plain
     // ISO-2022-JP (JIS X 0212, the non-Japanese G2 sets, and the SO/SI katakana shifts
     // cp50222 uses) decode to replacement characters, but the Japanese text around them
@@ -201,15 +188,12 @@ const charsetAliases = new Map([
     ['iso2022jp1', 'iso-2022-jp'],
     ['iso2022jp2', 'iso-2022-jp'],
     ['junet', 'iso-2022-jp'],
-
     // Korean. The WHATWG euc-kr index is the extended cp949 / UHC index.
     ['euckr', 'euc-kr'],
     ['uhc', 'euc-kr'],
-
     // Thai.
     ['tis620', 'windows-874']
 ]);
-
 // Windows and IBM code page numbers, as written in labels like cp932, windows-932, ms932
 // or ibm932. An explicit allowlist rather than a derived one, because plenty of code
 // pages that appear in mail (cp437, cp850, cp1361) have no equivalent to map onto and
@@ -227,114 +211,108 @@ const codePageAliases = new Map([
     ['50221', 'iso-2022-jp'],
     ['50222', 'iso-2022-jp']
 ]);
-
 const codePagePattern = /^(?:cp|windows|ms|ibm)(\d+)$/;
-
 // Strip the decorations mail clients add to an otherwise standard label: an x- vendor
 // prefix, the IANA cs- prefix, and any separators.
 function normalizeCharset(charset) {
     return charset.replace(/^(?:x-ms-|x-|cs)/, '').replace(/[\s._-]+/g, '');
 }
-
 // Every label of the WHATWG Encoding Standard, https://encoding.spec.whatwg.org/encodings.json
 //
 // TextDecoder accepts these and nothing else, so a label outside the list is turned away
 // without constructing a decoder for it. Letting the constructor throw instead costs
 // several times the decode itself, and a message controls how often it happens: once
 // per encoded word, twice when the label also fails after normalization.
-const ENCODING_LABELS = new Set(
-    [
-        // UTF-8
-        'unicode-1-1-utf-8 unicode11utf8 unicode20utf8 utf-8 utf8 x-unicode20utf8',
-        // IBM866
-        '866 cp866 csibm866 ibm866',
-        // ISO-8859-2
-        'csisolatin2 iso-8859-2 iso-ir-101 iso8859-2 iso88592 iso_8859-2 iso_8859-2:1987 l2 latin2',
-        // ISO-8859-3
-        'csisolatin3 iso-8859-3 iso-ir-109 iso8859-3 iso88593 iso_8859-3 iso_8859-3:1988 l3 latin3',
-        // ISO-8859-4
-        'csisolatin4 iso-8859-4 iso-ir-110 iso8859-4 iso88594 iso_8859-4 iso_8859-4:1988 l4 latin4',
-        // ISO-8859-5
-        'csisolatincyrillic cyrillic iso-8859-5 iso-ir-144 iso8859-5 iso88595 iso_8859-5 iso_8859-5:1988',
-        // ISO-8859-6
-        'arabic asmo-708 csiso88596e csiso88596i csisolatinarabic ecma-114 iso-8859-6 iso-8859-6-e',
-        'iso-8859-6-i iso-ir-127 iso8859-6 iso88596 iso_8859-6 iso_8859-6:1987',
-        // ISO-8859-7
-        'csisolatingreek ecma-118 elot_928 greek greek8 iso-8859-7 iso-ir-126 iso8859-7 iso88597 iso_8859-7',
-        'iso_8859-7:1987 sun_eu_greek',
-        // ISO-8859-8
-        'csiso88598e csisolatinhebrew hebrew iso-8859-8 iso-8859-8-e iso-ir-138 iso8859-8 iso88598 iso_8859-8',
-        'iso_8859-8:1988 visual',
-        // ISO-8859-8-I
-        'csiso88598i iso-8859-8-i logical',
-        // ISO-8859-10
-        'csisolatin6 iso-8859-10 iso-ir-157 iso8859-10 iso885910 l6 latin6',
-        // ISO-8859-13
-        'iso-8859-13 iso8859-13 iso885913',
-        // ISO-8859-14
-        'iso-8859-14 iso8859-14 iso885914',
-        // ISO-8859-15
-        'csisolatin9 iso-8859-15 iso8859-15 iso885915 iso_8859-15 l9',
-        // ISO-8859-16
-        'iso-8859-16',
-        // KOI8-R
-        'cskoi8r koi koi8 koi8-r koi8_r',
-        // KOI8-U
-        'koi8-ru koi8-u',
-        // macintosh
-        'csmacintosh mac macintosh x-mac-roman',
-        // windows-874
-        'dos-874 iso-8859-11 iso8859-11 iso885911 tis-620 windows-874',
-        // windows-1250
-        'cp1250 windows-1250 x-cp1250',
-        // windows-1251
-        'cp1251 windows-1251 x-cp1251',
-        // windows-1252
-        'ansi_x3.4-1968 ascii cp1252 cp819 csisolatin1 ibm819 iso-8859-1 iso-ir-100 iso8859-1 iso88591',
-        'iso_8859-1 iso_8859-1:1987 l1 latin1 us-ascii windows-1252 x-cp1252',
-        // windows-1253
-        'cp1253 windows-1253 x-cp1253',
-        // windows-1254
-        'cp1254 csisolatin5 iso-8859-9 iso-ir-148 iso8859-9 iso88599 iso_8859-9 iso_8859-9:1989 l5 latin5',
-        'windows-1254 x-cp1254',
-        // windows-1255
-        'cp1255 windows-1255 x-cp1255',
-        // windows-1256
-        'cp1256 windows-1256 x-cp1256',
-        // windows-1257
-        'cp1257 windows-1257 x-cp1257',
-        // windows-1258
-        'cp1258 windows-1258 x-cp1258',
-        // x-mac-cyrillic
-        'x-mac-cyrillic x-mac-ukrainian',
-        // GBK
-        'chinese csgb2312 csiso58gb231280 gb2312 gb_2312 gb_2312-80 gbk iso-ir-58 x-gbk',
-        // gb18030
-        'gb18030',
-        // Big5
-        'big5 big5-hkscs cn-big5 csbig5 x-x-big5',
-        // EUC-JP
-        'cseucpkdfmtjapanese euc-jp x-euc-jp',
-        // ISO-2022-JP
-        'csiso2022jp iso-2022-jp',
-        // Shift_JIS
-        'csshiftjis ms932 ms_kanji shift-jis shift_jis sjis windows-31j x-sjis',
-        // EUC-KR
-        'cseuckr csksc56011987 euc-kr iso-ir-149 korean ks_c_5601-1987 ks_c_5601-1989 ksc5601 ksc_5601',
-        'windows-949',
-        // replacement
-        'csiso2022kr hz-gb-2312 iso-2022-cn iso-2022-cn-ext iso-2022-kr replacement',
-        // UTF-16BE
-        'unicodefffe utf-16be',
-        // UTF-16LE
-        'csunicode iso-10646-ucs-2 ucs-2 unicode unicodefeff utf-16 utf-16le',
-        // x-user-defined
-        'x-user-defined'
-    ]
-        .join(' ')
-        .split(' ')
-);
-
+const ENCODING_LABELS = new Set([
+    // UTF-8
+    'unicode-1-1-utf-8 unicode11utf8 unicode20utf8 utf-8 utf8 x-unicode20utf8',
+    // IBM866
+    '866 cp866 csibm866 ibm866',
+    // ISO-8859-2
+    'csisolatin2 iso-8859-2 iso-ir-101 iso8859-2 iso88592 iso_8859-2 iso_8859-2:1987 l2 latin2',
+    // ISO-8859-3
+    'csisolatin3 iso-8859-3 iso-ir-109 iso8859-3 iso88593 iso_8859-3 iso_8859-3:1988 l3 latin3',
+    // ISO-8859-4
+    'csisolatin4 iso-8859-4 iso-ir-110 iso8859-4 iso88594 iso_8859-4 iso_8859-4:1988 l4 latin4',
+    // ISO-8859-5
+    'csisolatincyrillic cyrillic iso-8859-5 iso-ir-144 iso8859-5 iso88595 iso_8859-5 iso_8859-5:1988',
+    // ISO-8859-6
+    'arabic asmo-708 csiso88596e csiso88596i csisolatinarabic ecma-114 iso-8859-6 iso-8859-6-e',
+    'iso-8859-6-i iso-ir-127 iso8859-6 iso88596 iso_8859-6 iso_8859-6:1987',
+    // ISO-8859-7
+    'csisolatingreek ecma-118 elot_928 greek greek8 iso-8859-7 iso-ir-126 iso8859-7 iso88597 iso_8859-7',
+    'iso_8859-7:1987 sun_eu_greek',
+    // ISO-8859-8
+    'csiso88598e csisolatinhebrew hebrew iso-8859-8 iso-8859-8-e iso-ir-138 iso8859-8 iso88598 iso_8859-8',
+    'iso_8859-8:1988 visual',
+    // ISO-8859-8-I
+    'csiso88598i iso-8859-8-i logical',
+    // ISO-8859-10
+    'csisolatin6 iso-8859-10 iso-ir-157 iso8859-10 iso885910 l6 latin6',
+    // ISO-8859-13
+    'iso-8859-13 iso8859-13 iso885913',
+    // ISO-8859-14
+    'iso-8859-14 iso8859-14 iso885914',
+    // ISO-8859-15
+    'csisolatin9 iso-8859-15 iso8859-15 iso885915 iso_8859-15 l9',
+    // ISO-8859-16
+    'iso-8859-16',
+    // KOI8-R
+    'cskoi8r koi koi8 koi8-r koi8_r',
+    // KOI8-U
+    'koi8-ru koi8-u',
+    // macintosh
+    'csmacintosh mac macintosh x-mac-roman',
+    // windows-874
+    'dos-874 iso-8859-11 iso8859-11 iso885911 tis-620 windows-874',
+    // windows-1250
+    'cp1250 windows-1250 x-cp1250',
+    // windows-1251
+    'cp1251 windows-1251 x-cp1251',
+    // windows-1252
+    'ansi_x3.4-1968 ascii cp1252 cp819 csisolatin1 ibm819 iso-8859-1 iso-ir-100 iso8859-1 iso88591',
+    'iso_8859-1 iso_8859-1:1987 l1 latin1 us-ascii windows-1252 x-cp1252',
+    // windows-1253
+    'cp1253 windows-1253 x-cp1253',
+    // windows-1254
+    'cp1254 csisolatin5 iso-8859-9 iso-ir-148 iso8859-9 iso88599 iso_8859-9 iso_8859-9:1989 l5 latin5',
+    'windows-1254 x-cp1254',
+    // windows-1255
+    'cp1255 windows-1255 x-cp1255',
+    // windows-1256
+    'cp1256 windows-1256 x-cp1256',
+    // windows-1257
+    'cp1257 windows-1257 x-cp1257',
+    // windows-1258
+    'cp1258 windows-1258 x-cp1258',
+    // x-mac-cyrillic
+    'x-mac-cyrillic x-mac-ukrainian',
+    // GBK
+    'chinese csgb2312 csiso58gb231280 gb2312 gb_2312 gb_2312-80 gbk iso-ir-58 x-gbk',
+    // gb18030
+    'gb18030',
+    // Big5
+    'big5 big5-hkscs cn-big5 csbig5 x-x-big5',
+    // EUC-JP
+    'cseucpkdfmtjapanese euc-jp x-euc-jp',
+    // ISO-2022-JP
+    'csiso2022jp iso-2022-jp',
+    // Shift_JIS
+    'csshiftjis ms932 ms_kanji shift-jis shift_jis sjis windows-31j x-sjis',
+    // EUC-KR
+    'cseuckr csksc56011987 euc-kr iso-ir-149 korean ks_c_5601-1987 ks_c_5601-1989 ksc5601 ksc_5601',
+    'windows-949',
+    // replacement
+    'csiso2022kr hz-gb-2312 iso-2022-cn iso-2022-cn-ext iso-2022-kr replacement',
+    // UTF-16BE
+    'unicodefffe utf-16be',
+    // UTF-16LE
+    'csunicode iso-10646-ucs-2 ucs-2 unicode unicodefeff utf-16 utf-16le',
+    // x-user-defined
+    'x-user-defined'
+]
+    .join(' ')
+    .split(' '));
 // Decoders by label, or null where the runtime refuses the label (the replacement
 // encoding, or an encoding a runtime was built without). Only labels from the list above
 // are stored, so the map can not grow past it however many labels a message makes up.
@@ -342,75 +320,66 @@ const ENCODING_LABELS = new Set(
 // Sharing a decoder is safe because nothing decodes with `stream: true`, so every
 // decode() call starts from a fresh state.
 const decoders = new Map();
-
 function tryDecoder(charset) {
     if (!ENCODING_LABELS.has(charset)) {
         return null;
     }
-
-    if (!decoders.has(charset)) {
-        let decoder = null;
+    let decoder = decoders.get(charset);
+    if (decoder === undefined) {
+        decoder = null;
         try {
             decoder = new TextDecoder(charset);
-        } catch (err) {
+        }
+        catch {
             // not supported by this runtime
         }
         decoders.set(charset, decoder);
     }
-
-    return decoders.get(charset);
+    return decoder;
 }
-
+// Every runtime has utf-8, so a decoder is always returned even where windows-1252 is
+// missing, rather than letting the caller fail on a null decoder
+const utf8Decoder = new TextDecoder();
 function getDecoder(charset) {
     charset = (charset || 'utf8').trim().toLowerCase();
-
     // Try the label as written first, so the alias table only ever adds to what the
     // runtime already supports instead of shadowing it.
     const decoder = tryDecoder(charset);
     if (decoder) {
         return decoder;
     }
-
     const normalized = normalizeCharset(charset);
     const codePage = normalized.match(codePagePattern);
-
     // The normalized label is itself the last candidate, which resolves everything that
     // differed from a supported label only by a prefix or a separator, eg. x-big5.
     const alias = (codePage && codePageAliases.get(codePage[1])) || charsetAliases.get(normalized) || normalized;
-
-    return tryDecoder(alias) || tryDecoder('windows-1252');
+    return tryDecoder(alias) || tryDecoder('windows-1252') || utf8Decoder;
 }
-
 /**
  * Converts a Blob into an ArrayBuffer
- * @param {Blob} blob Blob to convert
- * @returns {ArrayBuffer} Converted value
+ * @param blob Blob to convert
+ * @returns Converted value
  */
 async function blobToArrayBuffer(blob) {
     if ('arrayBuffer' in blob) {
         return await blob.arrayBuffer();
     }
-
     const fr = new FileReader();
-
     return new Promise((resolve, reject) => {
-        fr.onload = function (e) {
-            resolve(e.target.result);
+        fr.onload = () => {
+            resolve(fr.result);
         };
-
-        fr.onerror = function (e) {
+        fr.onerror = () => {
             reject(fr.error);
         };
-
         fr.readAsArrayBuffer(blob);
     });
 }
-
 /**
  * Numeric value of an ASCII hex digit
  *
- * @param {Number} c Byte to read
- * @return {Number} Value 0-15, or -1 if the byte is not a hex digit
+ * @param c Byte to read
+ * @return Value 0-15, or -1 if the byte is not a hex digit
  */
 function hexNibble(c) {
     if (c >= 0x30 /* 0 */ && c <= 0x39 /* 9 */) {
@@ -424,12 +393,13 @@ function hexNibble(c) {
     }
     return -1;
 }
-
 /**
  * Decode a complete mime word encoded string
  *
- * @param {String} str Mime word encoded string
- * @return {String} Decoded unicode string
+ * @param charset Character set of the encoded word
+ * @param encoding `Q` or `B`
+ * @param str Mime word encoded string
+ * @return Decoded unicode string
  */
 function decodeWord(charset, encoding, str) {
     // RFC2231 added language tag to the encoding
@@ -437,20 +407,16 @@ function decodeWord(charset, encoding, str) {
     // this implementation silently ignores this tag
     let splitPos = charset.indexOf('*');
     if (splitPos >= 0) {
-        charset = charset.substr(0, splitPos);
+        charset = charset.slice(0, splitPos);
     }
-
     encoding = encoding.toUpperCase();
-
     let byteStr;
-
     if (encoding === 'Q') {
         str = str
             // remove spaces between = and hex char, this might indicate invalidly applied line splitting
             .replace(/=\s+([0-9a-fA-F])/g, '=$1')
             // convert all underscores to spaces
             .replace(/[_\s]/g, ' ');
-
         let buf = textEncoder.encode(str);
         let encodedBytes = [];
         for (let i = 0, len = buf.length; i < len; i++) {
@@ -471,38 +437,34 @@ function decodeWord(charset, encoding, str) {
         for (let i = 0, len = encodedBytes.length; i < len; i++) {
             dataView.setUint8(i, encodedBytes[i]);
         }
-    } else if (encoding === 'B') {
+    }
+    else if (encoding === 'B') {
         byteStr = decodeBase64(str.replace(/[^a-zA-Z0-9\+\/=]+/g, ''));
-    } else {
+    }
+    else {
         // keep as is, convert ArrayBuffer to unicode string, assume utf8
         byteStr = textEncoder.encode(str);
     }
-
     return getDecoder(charset).decode(byteStr);
 }
-
 // A charset label runs to the next '?' so that labels containing punctuation, eg.
 // ISO_8859-1:1987, are recognised. Whitespace is excluded so a stray '=?' in running text
 // can not swallow the rest of the line.
 const ENCODED_WORD_PATTERN = '=\\?([^?\\s]+)\\?([QqBb])\\?([^?]*)\\?=';
 const ENCODED_WORD_REGEX = new RegExp(ENCODED_WORD_PATTERN, 'g');
-
 // Only linear whitespace separates encoded words, the rest is content
 const WORD_SEPARATOR_REGEX = /^[ \t\r\n]+$/;
-
 const ENCODED_WORDS_ONLY_REGEX = new RegExp(`^(?:${ENCODED_WORD_PATTERN}\\s*)+$`);
-
 /**
  * Checks whether a string is nothing but RFC 2047 encoded words. Kept next to the grammar
  * it depends on, so the pattern has a single definition.
  *
- * @param {String} str String to check
- * @return {Boolean} true if the string holds encoded words and nothing else
+ * @param str String to check
+ * @return true if the string holds encoded words and nothing else
  */
 function isEncodedWordsOnly(str) {
     return ENCODED_WORDS_ONLY_REGEX.test(str);
 }
-
 /**
  * Splits a string into encoded words and the literal text around them.
  *
@@ -510,17 +472,14 @@ function isEncodedWordsOnly(str) {
  * means the input can not contain the marker, which previously let a sender delete text
  * from a subject or a display name by writing the marker into the header themselves.
  *
- * @param {String} str String to split
- * @return {Array} Array of `{text}` and `{charset, encoding, encodedText}` tokens
+ * @param str String to split
+ * @return Array of `{text}` and `{charset, encoding, encodedText}` tokens
  */
 function splitEncodedWords(str) {
     const tokens = [];
-
     ENCODED_WORD_REGEX.lastIndex = 0;
-
     let pos = 0;
     let match;
-
     while ((match = ENCODED_WORD_REGEX.exec(str))) {
         if (match.index > pos) {
             tokens.push({ text: str.substring(pos, match.index) });
@@ -528,14 +487,11 @@ function splitEncodedWords(str) {
         tokens.push({ charset: match[1], encoding: match[2], encodedText: match[3] });
         pos = match.index + match[0].length;
     }
-
     if (pos < str.length) {
         tokens.push({ text: str.substring(pos) });
     }
-
     return tokens;
 }
-
 /**
  * Checks if two adjacent encoded words may be decoded as a single unit. A multi byte
  * character is often split across two words, so the bytes have to be concatenated before
@@ -544,32 +500,26 @@ function splitEncodedWords(str) {
  */
 function canJoinWords(left, right) {
     const encoding = left.encoding.toUpperCase();
-
     if (left.charset !== right.charset || encoding !== right.encoding.toUpperCase()) {
         return false;
     }
-
     if (encoding === 'B') {
         return left.encodedText.length % 4 === 0 && !/=$/.test(left.encodedText);
     }
-
     return true;
 }
-
 /**
  * Decodes a token list into a string, optionally merging adjacent encoded words.
  *
- * @param {Array} tokens Tokens from splitEncodedWords
- * @param {Boolean} joinWords Whether adjacent encoded words may be decoded as one unit
- * @return {String} Decoded string
+ * @param tokens Tokens from splitEncodedWords
+ * @param joinWords Whether adjacent encoded words may be decoded as one unit
+ * @return Decoded string
  */
 function renderTokens(tokens, joinWords) {
     let result = '';
     let pending = null;
-
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
-
         if (token.text !== undefined) {
             // whitespace between two encoded words is a folding artifact, not content
             const nextToken = tokens[i + 1];
@@ -583,117 +533,103 @@ function renderTokens(tokens, joinWords) {
             result += token.text;
             continue;
         }
-
         if (pending && joinWords && canJoinWords(pending, token)) {
             pending.encodedText += token.encodedText;
             continue;
         }
-
         if (pending) {
             result += decodeWord(pending.charset, pending.encoding, pending.encodedText);
         }
         pending = { charset: token.charset, encoding: token.encoding, encodedText: token.encodedText };
     }
-
     if (pending) {
         result += decodeWord(pending.charset, pending.encoding, pending.encodedText);
     }
-
     return result;
 }
-
+/**
+ * Decodes RFC 2047 encoded words in a string
+ *
+ * @param str String that may contain encoded words
+ * @return Unicode string with every encoded word decoded
+ */
 function decodeWords(str) {
     const tokens = splitEncodedWords((str || '').toString());
-
     const result = renderTokens(tokens, true);
-
     // A replacement character means the bytes did not decode, which happens when two
     // words were joined that should have stayed apart. Retry keeping them separate.
     return result.indexOf('\ufffd') < 0 ? result : renderTokens(tokens, false);
 }
-
 function decodeURIComponentWithCharset(encodedStr, charset) {
     charset = charset || 'utf-8';
-
     let encodedBytes = [];
     for (let i = 0; i < encodedStr.length; i++) {
         let c = encodedStr.charAt(i);
-        if (c === '%' && /^[a-f0-9]{2}/i.test(encodedStr.substr(i + 1, 2))) {
+        // -1 past the end of the string as well, since charCodeAt returns NaN there
+        const high = c === '%' ? hexNibble(encodedStr.charCodeAt(i + 1)) : -1;
+        const low = high >= 0 ? hexNibble(encodedStr.charCodeAt(i + 2)) : -1;
+        if (low >= 0) {
             // encoded sequence
-            let byte = encodedStr.substr(i + 1, 2);
+            encodedBytes.push((high << 4) | low);
             i += 2;
-            encodedBytes.push(parseInt(byte, 16));
-        } else if (c.charCodeAt(0) > 126) {
-            c = textEncoder.encode(c);
-            for (let j = 0; j < c.length; j++) {
-                encodedBytes.push(c[j]);
+        }
+        else if (c.charCodeAt(0) > 126) {
+            const bytes = textEncoder.encode(c);
+            for (let j = 0; j < bytes.length; j++) {
+                encodedBytes.push(bytes[j]);
             }
-        } else {
+        }
+        else {
             // "normal" char
             encodedBytes.push(c.charCodeAt(0));
         }
     }
-
     const byteStr = new ArrayBuffer(encodedBytes.length);
     const dataView = new DataView(byteStr);
     for (let i = 0, len = encodedBytes.length; i < len; i++) {
         dataView.setUint8(i, encodedBytes[i]);
     }
-
     return getDecoder(charset).decode(byteStr);
 }
-
 function decodeParameterValueContinuations(header) {
     // handle parameter value continuations
     // https://tools.ietf.org/html/rfc2231#section-3
-
     // preprocess values
     let paramKeys = new Map();
-
     Object.keys(header.params).forEach(key => {
         let match = key.match(/\*((\d+)\*?)?$/);
         if (!match) {
             // nothing to do here, does not seem like a continuation param
             return;
         }
-
-        let actualKey = key.substr(0, match.index).toLowerCase();
+        let actualKey = key.slice(0, match.index).toLowerCase();
         let nr = Number(match[2]) || 0;
-
-        let paramVal;
-        if (!paramKeys.has(actualKey)) {
+        let paramVal = paramKeys.get(actualKey);
+        if (!paramVal) {
             paramVal = {
-                charset: false,
+                charset: null,
                 values: []
             };
             paramKeys.set(actualKey, paramVal);
-        } else {
-            paramVal = paramKeys.get(actualKey);
         }
-
         let value = header.params[key];
         // RFC 2231 section 4.1: only a section whose name ends in '*' is percent encoded.
         // A plain `name*0=` section is literal text, so decoding it invents characters
         // that never appeared on the wire, turning `a%2F..%2Fetc` into a path traversal.
         let encoded = match[0].charAt(match[0].length - 1) === '*';
-
         if (nr === 0 && encoded && (match = value.match(/^([^']*)'[^']*'(.*)$/))) {
             paramVal.charset = match[1] || 'utf-8';
             value = match[2];
         }
-
         paramVal.values.push({ nr, value, encoded });
-
         // remove the old reference
         delete header.params[key];
     });
-
     paramKeys.forEach((paramVal, key) => {
         let result = '';
         // Adjacent encoded sections are decoded together, because a single multi byte
         // character may be percent encoded across a section boundary.
         let pending = '';
-
         for (let part of paramVal.values.sort((a, b) => a.nr - b.nr)) {
             if (part.encoded) {
                 pending += part.value;
@@ -705,11 +641,9 @@ function decodeParameterValueContinuations(header) {
             }
             result += part.value;
         }
-
         if (pending) {
             result += decodeURIComponentWithCharset(pending, paramVal.charset);
         }
-
         header.params[key] = result;
     });
 }
@@ -718,12 +652,10 @@ class PassThroughDecoder {
     constructor() {
         this.chunks = [];
     }
-
     update(line) {
         this.chunks.push(line);
         this.chunks.push('\n');
     }
-
     finalize() {
         // convert an array of arraybuffers into a blob and then back into a single arraybuffer
         return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
@@ -733,30 +665,22 @@ class PassThroughDecoder {
 class Base64Decoder {
     constructor(opts) {
         opts = opts || {};
-
         this.decoder = opts.decoder || new TextDecoder();
-
         this.maxChunkSize = 100 * 1024;
-
         this.chunks = [];
-
         this.remainder = '';
     }
-
     pushChunk(base64Str) {
         if (base64Str.length) {
             this.chunks.push(decodeBase64(base64Str));
         }
     }
-
     flushRemainder() {
         this.pushChunk(this.remainder);
         this.remainder = '';
     }
-
     update(buffer) {
         let str = this.decoder.decode(buffer).replace(/[^a-zA-Z0-9+/=]+/g, '');
-
         // '=' terminates a base64 unit. Some mailers pad every line, and erasing the
         // padding used to concatenate the units, which knocked everything after the first
         // embedded pad out of 4 character alignment and decoded it to garbage.
@@ -768,41 +692,33 @@ class Base64Decoder {
                 this.flushRemainder();
             }
         }
-
         if (this.remainder.length >= this.maxChunkSize) {
             const alignedLength = Math.floor(this.remainder.length / 4) * 4;
             this.pushChunk(this.remainder.substring(0, alignedLength));
             this.remainder = this.remainder.substring(alignedLength);
         }
     }
-
     finalize() {
         this.flushRemainder();
-
         return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
     }
 }
 
 const CHR_EQUALS = 0x3d;
 const CHR_LF = 0x0a;
-
 class QPDecoder {
     constructor() {
         this.maxChunkSize = 100 * 1024;
-
         this.buffer = new Uint8Array(this.maxChunkSize);
         this.bufferPos = 0;
-
         this.chunks = [];
     }
-
     writeByte(byte) {
         if (this.bufferPos >= this.buffer.length) {
             this.flushBuffer();
         }
         this.buffer[this.bufferPos++] = byte;
     }
-
     // Literal text is the bulk of a typical body, so it is copied in runs rather than a
     // byte at a time
     writeBytes(line, start, end) {
@@ -816,55 +732,46 @@ class QPDecoder {
             start += count;
         }
     }
-
     flushBuffer() {
         if (this.bufferPos) {
             this.chunks.push(this.buffer.slice(0, this.bufferPos));
             this.bufferPos = 0;
         }
     }
-
     // Quoted-printable source is 7 bit by definition, so it is decoded byte by byte and
     // the result is handed on as bytes. Running the body charset over the encoded source
     // instead corrupted every part whose charset was not ASCII compatible: the same
     // content that decoded correctly in base64 came out as mojibake in quoted-printable.
     update(line) {
         let len = line.length;
-
         // a line ending in '=' is a soft line break, the newline is not part of the content
         const softBreak = len > 0 && line[len - 1] === CHR_EQUALS;
         if (softBreak) {
             len--;
         }
-
         let literalStart = 0;
         for (let i = 0; i < len; i++) {
             if (line[i] !== CHR_EQUALS || i + 2 >= len) {
                 continue;
             }
-
             const high = hexNibble(line[i + 1]);
             const low = hexNibble(line[i + 2]);
             if (high < 0 || low < 0) {
                 // not a valid escape sequence, keep it as literal text
                 continue;
             }
-
             this.writeBytes(line, literalStart, i);
             this.writeByte((high << 4) | low);
             i += 2;
             literalStart = i + 1;
         }
         this.writeBytes(line, literalStart, len);
-
         if (!softBreak) {
             this.writeByte(CHR_LF);
         }
     }
-
     finalize() {
         this.flushBuffer();
-
         // convert an array of arraybuffers into a blob and then back into a single arraybuffer
         return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
     }
@@ -875,19 +782,18 @@ class QPDecoder {
 // parser skips into a genuine header, which is how a second `From:` gets smuggled past
 // anything that inspects the raw message.
 const headerDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
-
 // Trims only the whitespace RFC 5322 allows around a field name. String.prototype.trim
 // also strips U+00A0, U+FEFF, U+2028 and the rest of the Unicode spaces, which turns a
-// line that a strict parser rejects into a canonical field name: ` From:` became a
-// `from` header, and since the first occurrence of a header wins it outranked the real
-// sender. Leaving the character in the key keeps the line visible without letting it
-// collide with a genuine header.
+// line that a strict parser rejects into a canonical field name: a `From:` line with a
+// leading U+00A0 became a `from` header, and since the first occurrence of a header wins
+// it outranked the real sender. Leaving the character in the key keeps the line visible
+// without letting it collide with a genuine header.
 //
 // An index scan rather than `/^[ \t]+|[ \t]+$/g`, which retries the trailing branch at
 // every position of a blank run that is followed by other text, so a single header with
 // a long run of spaces in the middle took seconds to trim.
-const isWsp = c => c === 0x20 || c === 0x09;
-const trimWsp = str => {
+const isWsp = (c) => c === 0x20 || c === 0x09;
+const trimWsp = (str) => {
     let start = 0;
     let end = str.length;
     while (start < end && isWsp(str.charCodeAt(start))) {
@@ -898,7 +804,6 @@ const trimWsp = str => {
     }
     return str.slice(start, end);
 };
-
 // Headers that decide how this part's body is read, see processHeaders
 const CONTENT_HEADERS = new Set([
     'content-type',
@@ -907,78 +812,69 @@ const CONTENT_HEADERS = new Set([
     'content-id',
     'content-description'
 ]);
-
 class MimeNode {
     constructor(options) {
-        this.options = options || {};
-
-        this.postalMime = this.options.postalMime;
-
+        this.options = options;
+        this.postalMime = options.postalMime;
         this.childNodes = [];
         // Cursor into childNodes for finalizeChildNodes. Every new part of a multipart
         // finalizes its parent's children, so re-walking the whole array each time is
         // quadratic in the number of parts.
         this.finalizedChildCount = 0;
-
-        if (this.options.parentNode) {
-            this.parentNode = this.options.parentNode;
-
+        if (options.parentNode) {
+            this.parentNode = options.parentNode;
             this.depth = this.parentNode.depth + 1;
-            if (this.depth > this.options.maxNestingDepth) {
-                throw new Error(`Maximum MIME nesting depth of ${this.options.maxNestingDepth} levels exceeded`);
+            if (this.depth > options.maxNestingDepth) {
+                throw new Error(`Maximum MIME nesting depth of ${options.maxNestingDepth} levels exceeded`);
             }
-
-            this.options.parentNode.childNodes.push(this);
-        } else {
+            options.parentNode.childNodes.push(this);
+        }
+        else {
             this.depth = 0;
         }
-
         this.state = 'header';
-
         this.headerLines = [];
-
         // RFC 2046 Section 5.1.5: multipart/digest defaults to message/rfc822
-        const parentMultipartType = this.options.parentMultipartType || null;
+        const parentMultipartType = options.parentMultipartType || null;
         const defaultContentType = parentMultipartType === 'digest' ? 'message/rfc822' : 'text/plain';
-
-        // Replaced by the first matching header, see the CONTENT_HEADERS pass in
-        // processHeaders
+        // The value is replaced by the first matching header and the rest is derived
+        // from it, see the CONTENT_HEADERS pass in processHeaders
         this.contentType = {
-            value: defaultContentType
+            value: defaultContentType,
+            parsed: { value: defaultContentType, params: {} },
+            multipart: false
         };
-
         this.contentTransferEncoding = {
-            value: '8bit'
+            value: '8bit',
+            encoding: ''
         };
-
         this.contentDisposition = {
-            value: ''
+            value: '',
+            parsed: { value: '', params: {} }
         };
-
         this.headers = [];
-
-        this.contentDecoder = false;
+        this.rawHeaderLines = [];
+        this.contentDecoder = null;
+        this.content = null;
     }
-
     setupContentDecoder(transferEncoding) {
         if (/base64/i.test(transferEncoding)) {
             this.contentDecoder = new Base64Decoder();
-        } else if (/quoted-printable/i.test(transferEncoding)) {
+        }
+        else if (/quoted-printable/i.test(transferEncoding)) {
             this.contentDecoder = new QPDecoder();
-        } else {
+        }
+        else {
             this.contentDecoder = new PassThroughDecoder();
         }
     }
-
     async finalize() {
         if (this.state === 'finished') {
             return;
         }
-
         if (this.state === 'header') {
             this.processHeaders();
         }
-
         // remove self from boundary listing
         let boundaries = this.postalMime.boundaries;
         for (let i = boundaries.length - 1; i >= 0; i--) {
@@ -988,19 +884,14 @@ class MimeNode {
                 break;
             }
         }
-
         await this.finalizeChildNodes();
-
         this.content = this.contentDecoder ? await this.contentDecoder.finalize() : null;
-
         // The decoder buffers every body line it received, so keeping it around
         // retains a second copy of the content for the lifetime of the node.
         // Nothing reads it once the node is finished, so release it here.
-        this.contentDecoder = false;
-
+        this.contentDecoder = null;
         this.state = 'finished';
     }
-
     async finalizeChildNodes() {
         // Children are only ever appended, so everything before the cursor is already
         // finished and re-visiting it only costs time.
@@ -1008,7 +899,6 @@ class MimeNode {
             await this.childNodes[this.finalizedChildCount++].finalize();
         }
     }
-
     // Strip RFC 822 comments (parenthesized text) from structured header values.
     //
     // Inside an unquoted parameter value a parenthesis that continues the current token is
@@ -1023,24 +913,20 @@ class MimeNode {
         let commentStart = -1;
         // A parameter value starts at `=` and ends at the `;` that begins the next one
         let inParameterValue = false;
-
         // Whether result ends in SP or HTAB. Kept up to date on every append, because
         // testing `/[ \t]$/` against result flattens the whole string on each `(` and is
         // quadratic in the length of the header.
         let endsWithWsp = false;
-        const append = c => {
+        const append = (c) => {
             result += c;
             endsWithWsp = c === ' ' || c === '\t';
         };
-
         // A comment may only appear where linear whitespace is allowed, so inside a
         // parameter value the parenthesis has to follow whitespace to open one. Outside
         // one, eg. after the type itself, anything goes.
         const opensComment = () => !inParameterValue || !result.length || endsWithWsp;
-
         for (let i = 0; i < str.length; i++) {
             const chr = str.charAt(i);
-
             if (escaped) {
                 if (depth === 0) {
                     append(chr);
@@ -1048,7 +934,6 @@ class MimeNode {
                 escaped = false;
                 continue;
             }
-
             if (chr === '\\') {
                 escaped = true;
                 if (depth === 0) {
@@ -1056,13 +941,11 @@ class MimeNode {
                 }
                 continue;
             }
-
             if (chr === '"' && depth === 0) {
                 inQuote = !inQuote;
                 append(chr);
                 continue;
             }
-
             if (!inQuote) {
                 if (chr === '(' && opensComment()) {
                     if (depth === 0) {
@@ -1078,40 +961,34 @@ class MimeNode {
                 if (depth === 0) {
                     if (chr === '=') {
                         inParameterValue = true;
-                    } else if (chr === ';') {
+                    }
+                    else if (chr === ';') {
                         inParameterValue = false;
                     }
                 }
             }
-
             if (depth === 0) {
                 append(chr);
             }
         }
-
         if (depth === 0) {
             return result;
         }
-
         // An unbalanced `(` is not a comment. Dropping everything after it would take any
         // parameter that follows with it, including the boundary that holds the message
         // together, so the dangling text is only discarded when nothing follows it.
         return str.indexOf(';', commentStart) < 0 ? result : str;
     }
-
     parseStructuredHeader(str) {
         // Strip RFC 822 comments before parsing
         str = this.stripComments(str);
-
         let response = {
-            value: false,
+            value: '',
             params: {}
         };
-
         let key = false;
         let value = '';
         let stage = 'value';
-
         // Whitespace seen outside a quoted string is held back until a significant
         // character follows it, so surrounding whitespace can be dropped without
         // trimming spaces the sender quoted on purpose. Trimming the stored value
@@ -1119,19 +996,16 @@ class MimeNode {
         // next continuation section is meant to be appended to.
         let pendingSpace = '';
         let quoteClosed = false;
-
         let quote = false;
         let escaped = false;
         let chr;
-
-        const addChr = c => {
+        const addChr = (c) => {
             if (value.length) {
                 value += pendingSpace;
             }
             pendingSpace = '';
             value += c;
         };
-
         const takeValue = () => {
             const result = value;
             value = '';
@@ -1139,7 +1013,6 @@ class MimeNode {
             quoteClosed = false;
             return result;
         };
-
         // A duplicated parameter resolves to its first occurrence, matching how duplicated
         // headers are resolved. Letting the last one win means `boundary="b"; boundary="c"`
         // registers a boundary that no delimiter in the message matches, which drops the
@@ -1150,16 +1023,15 @@ class MimeNode {
                 response.params[name] = result;
             }
         };
-
         const storeValue = () => {
             const result = takeValue();
             if (key === false) {
                 response.value = result;
-            } else {
+            }
+            else {
                 storeParam(key, result);
             }
         };
-
         // A parameter name with no `=` is a valueless parameter, not the start of the
         // next one. Without this the name would keep growing across the `;` and swallow
         // whatever followed, which is how `x=1; flag; boundary="AAA"` loses its boundary.
@@ -1169,7 +1041,6 @@ class MimeNode {
                 storeParam(name.toLowerCase(), '');
             }
         };
-
         for (let i = 0, len = str.length; i < len; i++) {
             chr = str.charAt(i);
             switch (stage) {
@@ -1188,16 +1059,19 @@ class MimeNode {
                 case 'value':
                     if (escaped) {
                         addChr(chr);
-                    } else if (quote && chr === '\\') {
+                    }
+                    else if (quote && chr === '\\') {
                         // backslash only escapes inside a quoted string, everywhere else
                         // it is an ordinary character. Treating it as an escape turns
                         // `filename=C:\Users\me\a.txt` into `C:Usersmea.txt`.
                         escaped = true;
                         continue;
-                    } else if (quote && chr === quote) {
+                    }
+                    else if (quote && chr === quote) {
                         quote = false;
                         quoteClosed = true;
-                    } else if (!quote && chr === '"') {
+                    }
+                    else if (!quote && chr === '"') {
                         quote = chr;
                         // whitespace before a quote that opens the value is padding, but
                         // between a token and a quoted string it is content
@@ -1205,12 +1079,15 @@ class MimeNode {
                             value += pendingSpace;
                         }
                         pendingSpace = '';
-                    } else if (!quote && chr === ';') {
+                    }
+                    else if (!quote && chr === ';') {
                         storeValue();
                         stage = 'key';
-                    } else if (!quote && (chr === ' ' || chr === '\t')) {
+                    }
+                    else if (!quote && (chr === ' ' || chr === '\t')) {
                         pendingSpace += chr;
-                    } else if (!quoteClosed) {
+                    }
+                    else if (!quoteClosed) {
                         addChr(chr);
                     }
                     // Anything else is trailing junk after a closed quoted string. RFC 2045
@@ -1221,26 +1098,22 @@ class MimeNode {
                     break;
             }
         }
-
         // finalize remainder
         if (stage === 'value') {
             storeValue();
-        } else {
+        }
+        else {
             // treat as key without value, see emptykey:
             // Header-Key: somevalue; key=value; emptykey
             storeEmptyKey();
         }
-
         if (response.value) {
             response.value = response.value.toLowerCase();
         }
-
         // convert Parameter Value Continuations into single strings
         decodeParameterValueContinuations(response);
-
         return response;
     }
-
     decodeFlowedText(str, delSp) {
         // Pieces of the result, joined once at the end. Growing a single string and
         // calling endsWith() on it for every line flattens the whole paragraph again on
@@ -1252,11 +1125,9 @@ class MimeNode {
         // starts at this index of parts and is this many characters long
         let lineStart = 0;
         let lineLength = 0;
-
         const lines = str.split(/\r?\n/);
         for (let i = 0; i < lines.length; i++) {
             let line = lines[i];
-
             // remove whitespace stuffing before anything else
             // http://tools.ietf.org/html/rfc3676#section-4.4
             // doing it after the join leaves the stuffed space of a continuation line
@@ -1264,55 +1135,47 @@ class MimeNode {
             if (line.charAt(0) === ' ') {
                 line = line.slice(1);
             }
-
             if (i) {
                 const last = parts.length ? parts[parts.length - 1] : '';
-
                 // soft linebreaks are added after space symbols, except for the signature
                 // separator which is a line of its own
                 const isSignature = lineLength === 3 && parts.slice(lineStart).join('') === '-- ';
-
                 if (last.endsWith(' ') && !isSignature) {
                     if (delSp) {
                         // delsp adds space to text to be able to fold it
                         // these spaces can be removed once the text is unfolded
                         if (last.length > 1) {
                             parts[parts.length - 1] = last.slice(0, -1);
-                        } else {
+                        }
+                        else {
                             parts.pop();
                         }
                         lineLength--;
                     }
-                } else {
+                }
+                else {
                     parts.push('\n');
                     lineStart = parts.length;
                     lineLength = 0;
                 }
             }
-
             if (line) {
                 parts.push(line);
                 lineLength += line.length;
             }
         }
-
         return parts.join('');
     }
-
     getTextContent() {
         if (!this.content) {
             return '';
         }
-
         let str = getDecoder(this.contentType.parsed.params.charset).decode(this.content);
-
         if (/^flowed$/i.test(this.contentType.parsed.params.format)) {
             str = this.decodeFlowedText(str, /^yes$/i.test(this.contentType.parsed.params.delsp));
         }
-
         return str;
     }
-
     processHeaders() {
         // First pass: group folded continuation lines with the header they belong to.
         //
@@ -1329,43 +1192,35 @@ class MimeNode {
         for (let line of this.headerLines) {
             if (foldedLines.length && /^[ \t]/.test(line)) {
                 foldedLines[foldedLines.length - 1].push(line);
-            } else {
+            }
+            else {
                 foldedLines.push([line]);
             }
         }
-
-        // Initialize rawHeaderLines to store unmodified lines
-        this.rawHeaderLines = [];
-
         let seenContentHeaders = new Set();
-
         // Second pass: process headers in document order
         for (let parts of foldedLines) {
             let rawLine = parts.join('\n');
-
             // Extract key from raw line for rawHeaderLines
             let sep = rawLine.indexOf(':');
-            let rawKey = trimWsp(sep < 0 ? rawLine : rawLine.substr(0, sep));
-
+            let rawKey = trimWsp(sep < 0 ? rawLine : rawLine.slice(0, sep));
             // Store raw line with lowercase key
             this.rawHeaderLines.push({
                 key: rawKey.toLowerCase(),
                 line: rawLine
             });
-
             // Unfolding removes the line break and keeps the folding whitespace, so
             // `Subject: Hello\r\n    World` stays `Hello    World`. Collapsing every
             // whitespace run instead also rewrote boundary values and filenames, and it
             // replaced the non-ASCII spaces that raw UTF-8 headers (RFC 6532) may carry.
             let unfoldedLine = parts.join('');
             sep = unfoldedLine.indexOf(':');
-            let key = trimWsp(sep < 0 ? unfoldedLine : unfoldedLine.substr(0, sep));
+            let key = trimWsp(sep < 0 ? unfoldedLine : unfoldedLine.slice(0, sep));
             // A bare CR is not legal in a field body. It used to be folded into a space by
             // the whitespace collapse, and passing it through would hand consumers that
             // write the value back out a line of their own.
-            let value = sep < 0 ? '' : trimWsp(unfoldedLine.substr(sep + 1).replace(/[\r\n]+/g, ' '));
+            let value = sep < 0 ? '' : trimWsp(unfoldedLine.slice(sep + 1).replace(/[\r\n]+/g, ' '));
             this.headers.push({ key: key.toLowerCase(), originalKey: key, value });
-
             // A header that decides how the body is read must resolve the same way every
             // time it is duplicated, otherwise a message can present one Content-Type to a
             // scanner and a different one here. Every one of these takes the first
@@ -1373,16 +1228,15 @@ class MimeNode {
             const lowerKey = key.toLowerCase();
             if (CONTENT_HEADERS.has(lowerKey) && !seenContentHeaders.has(lowerKey)) {
                 seenContentHeaders.add(lowerKey);
-
                 switch (lowerKey) {
                     case 'content-type':
-                        this.contentType = { value, parsed: {} };
+                        this.contentType.value = value;
                         break;
                     case 'content-transfer-encoding':
-                        this.contentTransferEncoding = { value, parsed: {} };
+                        this.contentTransferEncoding.value = value;
                         break;
                     case 'content-disposition':
-                        this.contentDisposition = { value, parsed: {} };
+                        this.contentDisposition.value = value;
                         break;
                     case 'content-id':
                         this.contentId = value;
@@ -1393,12 +1247,10 @@ class MimeNode {
                 }
             }
         }
-
         this.contentType.parsed = this.parseStructuredHeader(this.contentType.value);
         this.contentType.multipart = /^multipart\//i.test(this.contentType.parsed.value)
-            ? this.contentType.parsed.value.substr(this.contentType.parsed.value.indexOf('/') + 1)
+            ? this.contentType.parsed.value.slice(this.contentType.parsed.value.indexOf('/') + 1)
             : false;
-
         if (this.contentType.multipart && this.contentType.parsed.params.boundary) {
             // add self to boundary terminator listing
             this.postalMime.boundaries.push({
@@ -1406,9 +1258,7 @@ class MimeNode {
                 node: this
             });
         }
-
         this.contentDisposition.parsed = this.parseStructuredHeader(this.contentDisposition.value);
-
         // Take the first token rather than splitting on the first non-token character.
         // `split()` returns an empty string for anything that does not start with a word
         // character, so `(comment) base64` and `"base64"` used to fall through to the
@@ -1416,34 +1266,34 @@ class MimeNode {
         this.contentTransferEncoding.encoding = (this.stripComments(this.contentTransferEncoding.value)
             .toLowerCase()
             .match(/[\w-]+/) || [''])[0];
-
         this.setupContentDecoder(this.contentTransferEncoding.encoding);
     }
-
     feed(line) {
         switch (this.state) {
             case 'header':
                 if (!line.length) {
                     this.state = 'body';
-                    return this.processHeaders();
+                    this.processHeaders();
+                    return;
                 }
-
                 // Counted across the whole message, not per part. A per-node budget lets a
                 // multipart carry the limit again for every part it declares, so a message
                 // many times over the limit still parses.
                 this.postalMime.headerSize += line.length;
-
                 if (this.postalMime.headerSize > this.options.maxHeadersSize) {
                     let error = new Error(`Maximum header size of ${this.options.maxHeadersSize} bytes exceeded`);
                     throw error;
                 }
-
                 this.headerLines.push(headerDecoder.decode(line));
                 break;
-            case 'body': {
-                // add line to body
-                this.contentDecoder.update(line);
-            }
+            case 'body':
+                // add line to body. processHeaders installs a decoder before the state
+                // becomes body, and the only time the decoder is released is finalize,
+                // which moves the state on to finished, so the guard only narrows the type
+                if (this.contentDecoder) {
+                    this.contentDecoder.update(line);
+                }
+                break;
         }
     }
 }
@@ -3688,40 +3538,33 @@ function decodeHTMLEntities(str) {
         if (typeof htmlEntities[match] === 'string') {
             return htmlEntities[match];
         }
-
         if (entity.charAt(0) !== '#' || match.charAt(match.length - 1) !== ';') {
             // keep as is, invalid or unknown sequence
             return match;
         }
-
         let codePoint;
         if (entity.charAt(1) === 'x') {
             // hex
-            codePoint = parseInt(entity.substr(2), 16);
-        } else {
+            codePoint = parseInt(entity.slice(2), 16);
+        }
+        else {
             // dec
-            codePoint = parseInt(entity.substr(1), 10);
+            codePoint = parseInt(entity.slice(1), 10);
         }
-
         let output = '';
-
         if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
             // Invalid range, return a replacement character instead
-            return '\uFFFD';
+            return '\ufffd';
         }
-
         if (codePoint > 0xffff) {
             codePoint -= 0x10000;
             output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
             codePoint = 0xdc00 | (codePoint & 0x3ff);
         }
-
         output += String.fromCharCode(codePoint);
-
         return output;
     });
 }
-
 function escapeHtml(str) {
     return str.trim().replace(/[<>"'?&]/g, c => {
         let hex = c.charCodeAt(0).toString(16);
@@ -3731,26 +3574,21 @@ function escapeHtml(str) {
         return '&#x' + hex.toUpperCase() + ';';
     });
 }
-
 function textToHtml(str) {
     let html = escapeHtml(str).replace(/\n/g, '<br />');
     return '<div>' + html + '</div>';
 }
-
 // htmlToText strips tags with regexes like `<br\b[^>]*>` and `<!--.*?-->`. Handed to
 // String#replace as they are, the engine tries every candidate in turn and a candidate
 // that does not close scans on to the next `>`, the end of the line or the end of the
 // input before giving up, so an html part holding many unclosed `<`, `<a ` or `<!--`
 // took seconds to minutes to convert. The helpers below give the same results in linear
 // time.
-
 // Characters that `.` does not match, so a `.*` can not run across them
 const LINE_TERMINATOR = /[\n\r\u2028\u2029]/g;
-
 function lastLineTerminator(str) {
     return Math.max(str.lastIndexOf('\n'), str.lastIndexOf('\r'), str.lastIndexOf('\u2028'), str.lastIndexOf('\u2029'));
 }
-
 /**
  * Returns a function that finds the next match of a global regex at or after a position.
  *
@@ -3758,14 +3596,13 @@ function lastLineTerminator(str) {
  * until a position passes it, and no match stays the answer for good. That way every part
  * of the string is scanned once, however many times it is asked about.
  *
- * @param {String} str String to search
- * @param {RegExp} regex Global regex to look for
- * @return {Function} `pos => match` of the next match, or null if there is none
+ * @param str String to search
+ * @param regex Global regex to look for
+ * @return `pos => match` of the next match, or null if there is none
  */
 function createFinder(str, regex) {
     let searchedFrom = Infinity;
     let found = null;
-
     return pos => {
         if (pos < searchedFrom || (found && pos > found.index)) {
             regex.lastIndex = pos;
@@ -3775,7 +3612,6 @@ function createFinder(str, regex) {
         return found;
     };
 }
-
 /**
  * `str.replace(pattern, replacement)` for a pattern shaped like `<tag\b[^>]*>`.
  *
@@ -3783,16 +3619,15 @@ function createFinder(str, regex) {
  * the last `>` can never match and is where every rescan happened. Leaving it out keeps
  * the native replace, and its speed, for everything else.
  *
- * @param {String} str String to process
- * @param {RegExp} pattern Global regex that ends on the first `>` after its start
- * @param {String} replacement Replacement text
- * @return {String} Processed string
+ * @param str String to process
+ * @param pattern Global regex that ends on the first `>` after its start
+ * @param replacement Replacement text
+ * @return Processed string
  */
 function replaceClosedTags(str, pattern, replacement) {
     const end = str.lastIndexOf('>') + 1;
     return str.slice(0, end).replace(pattern, replacement) + str.slice(end);
 }
-
 /**
  * `str.replace(pattern, replacement)` for a tag pattern that may fail even when a `>`
  * follows, like `<a\b[^>]*href...>`, or that runs on past its `>`.
@@ -3801,25 +3636,23 @@ function replaceClosedTags(str, pattern, replacement) {
  * either. A candidate that does not match skips every other candidate before the same
  * `>`, since those see the same tag body and fail the same way.
  *
- * @param {String} str String to process
- * @param {RegExp} prefix Global regex for the start of a candidate, which can not contain `>`
- * @param {RegExp} pattern The whole pattern as a sticky regex
- * @param {Function} replacement Function given the match and its groups
- * @return {String} Processed string
+ * @param str String to process
+ * @param prefix Global regex for the start of a candidate, which can not contain `>`
+ * @param pattern The whole pattern as a sticky regex
+ * @param replacement Function given the match and its groups
+ * @return Processed string
  */
 function replaceTags(str, prefix, pattern, replacement) {
     const parts = [];
     // everything before this index is already in parts
     let copied = 0;
     let searchFrom = 0;
-
     while (true) {
         prefix.lastIndex = searchFrom;
         const candidate = prefix.exec(str);
         if (!candidate) {
             break;
         }
-
         const start = candidate.index;
         pattern.lastIndex = start;
         const match = pattern.exec(str);
@@ -3831,28 +3664,25 @@ function replaceTags(str, prefix, pattern, replacement) {
             searchFrom = gt + 1;
             continue;
         }
-
         parts.push(str.slice(copied, start), replacement(...match));
         copied = searchFrom = start + match[0].length;
     }
-
     parts.push(str.slice(copied));
     return parts.join('');
 }
-
 /**
  * `str.replace(pattern, replacement)` for a pattern like `<!--.*?-->` or
  * `<script\b[^>]*>.*?<\/script\b[^>]*>`, ie. an opener and a closer, either of which may
  * continue with `[^>]*>`, and a lazy `.*?` between them. The engine rescans to the end of
  * the line for every opener that is not closed.
  *
- * @param {String} str String to process
- * @param {RegExp} open Global regex for the opener
- * @param {Boolean} openToGt Whether the opener continues with `[^>]*>`
- * @param {RegExp} close Global regex for the closer
- * @param {Boolean} closeToGt Whether the closer continues with `[^>]*>`
- * @param {String} replacement Replacement text
- * @return {String} Processed string
+ * @param str String to process
+ * @param open Global regex for the opener
+ * @param openToGt Whether the opener continues with `[^>]*>`
+ * @param close Global regex for the closer
+ * @param closeToGt Whether the closer continues with `[^>]*>`
+ * @param replacement Replacement text
+ * @return Processed string
  */
 function replaceBlocks(str, open, openToGt, close, closeToGt, replacement) {
     const nextGt = createFinder(str, />/g);
@@ -3861,17 +3691,14 @@ function replaceBlocks(str, open, openToGt, close, closeToGt, replacement) {
     const parts = [];
     let copied = 0;
     let searchFrom = 0;
-
     while (true) {
         open.lastIndex = searchFrom;
         const opener = open.exec(str);
         if (!opener) {
             break;
         }
-
         const start = opener.index;
         searchFrom = start + 1;
-
         // where the lazy `.*?` starts
         let from = start + opener[0].length;
         if (openToGt) {
@@ -3882,19 +3709,16 @@ function replaceBlocks(str, open, openToGt, close, closeToGt, replacement) {
             }
             from = gt.index + 1;
         }
-
         const closer = nextClose(from);
         if (!closer) {
             // no closer follows this opener, so none follows a later one either
             break;
         }
-
         // `.*?` can not reach the closer across a line terminator
         const lineEnd = nextLineEnd(from);
         if (lineEnd && lineEnd.index < closer.index) {
             continue;
         }
-
         let end = closer.index + closer[0].length;
         if (closeToGt) {
             const gt = nextGt(end);
@@ -3905,62 +3729,52 @@ function replaceBlocks(str, open, openToGt, close, closeToGt, replacement) {
             }
             end = gt.index + 1;
         }
-
         parts.push(str.slice(copied, start), replacement);
         copied = searchFrom = end;
     }
-
     parts.push(str.slice(copied));
     return parts.join('');
 }
-
 /**
  * `str.replace(pattern, '')` for `^.*<tag\b[^>]*>`, ie. drops everything up to and
  * including the last such tag on the first line.
  *
- * @param {String} str String to process
- * @param {RegExp} prefix Global regex for the start of the tag, which can not contain `>`
- * @return {String} Processed string
+ * @param str String to process
+ * @param prefix Global regex for the start of the tag, which can not contain `>`
+ * @return Processed string
  */
 function stripThroughLastTag(str, prefix) {
     const lineEnd = str.search(LINE_TERMINATOR);
     // `.*` stops at the first line terminator, and `[^>]*>` needs a `>` after the tag
     const limit = Math.min(lineEnd < 0 ? str.length : lineEnd, str.lastIndexOf('>'));
-
     let last = -1;
     prefix.lastIndex = 0;
     let match;
     while ((match = prefix.exec(str)) && match.index < limit) {
         last = match.index;
     }
-
     return last < 0 ? str : str.slice(str.indexOf('>', last) + 1);
 }
-
 /**
  * `str.replace(pattern, '')` for `<tag\b[^>]*>.*$`, ie. drops the first such tag whose
  * `>` is on the last line, and everything after it.
  *
- * @param {String} str String to process
- * @param {RegExp} prefix Global regex for the start of the tag, which can not contain `>`
- * @return {String} Processed string
+ * @param str String to process
+ * @param prefix Global regex for the start of the tag, which can not contain `>`
+ * @return Processed string
  */
 function stripFromFirstTag(str, prefix) {
     // `.*$` has to reach the end of the string without crossing a line terminator, so the
     // tag has to start after the last `>` that comes before the last line terminator
     const lineEnd = lastLineTerminator(str);
     prefix.lastIndex = lineEnd < 0 ? 0 : str.lastIndexOf('>', lineEnd) + 1;
-
     const match = prefix.exec(str);
     return match && match.index < str.lastIndexOf('>') ? str.slice(0, match.index) : str;
 }
-
 function htmlToText(str) {
     // we can't process tags on multiple lines so remove newlines first
     str = str.replace(/\r?\n/g, '\u0001');
-
     str = replaceBlocks(str, /<!--/g, false, /-->/g, false, ' ');
-
     str = replaceClosedTags(str, /<br\b[^>]*>/gi, '\n');
     str = replaceClosedTags(str, /<\/?(p|div|table|tr|td|th)\b[^>]*>/gi, '\n\n');
     str = replaceBlocks(str, /<script\b/gi, true, /<\/script\b/gi, true, ' ');
@@ -3969,35 +3783,23 @@ function htmlToText(str) {
     str = stripThroughLastTag(str, /<!doctype\b/gi);
     str = stripFromFirstTag(str, /<\/body\b/gi);
     str = stripFromFirstTag(str, /<\/html\b/gi);
-
     str = replaceTags(str, /<a\b/gi, /<a\b[^>]*href\s*=\s*["']?([^\s"']+)[^>]*>/iy, (match, href) => ` (${href}) `);
-
     str = replaceClosedTags(str, /<\/?(span|em|i|strong|b|u|a)\b[^>]*>/gi, '');
-
     // the whitespace after the tag may run on past the last `>`
     str = replaceTags(str, /<li\b/gi, /<li\b[^>]*>[\n\u0001\s]*/iy, () => '* ');
-
     str = replaceClosedTags(str, /<hr\b[^>]*>/g, '\n-------------\n');
-
     str = replaceClosedTags(str, /<[^>]*>/g, ' ');
-
     str = str
         // convert linebreak placeholders back to newlines
         .replace(/\u0001/g, '\n')
-
         .replace(/[ \t]+/g, ' ')
-
         .replace(/^\s+$/gm, '')
-
         .replace(/\n\n+/g, '\n\n')
         .replace(/^\n+/, '\n')
         .replace(/\n+$/, '\n');
-
     str = decodeHTMLEntities(str);
-
     return str;
 }
-
 // A message date is not always a date. PostalMime keeps the raw header value when it does
 // not parse, and Intl.DateTimeFormat throws a RangeError on that, which used to reject the
 // whole parse of any message carrying a forwarded copy with a broken Date header.
@@ -4005,12 +3807,10 @@ function formatDate(date) {
     if (typeof Intl === 'undefined') {
         return date;
     }
-
     const parsed = new Date(date);
     if (isNaN(parsed.getTime())) {
         return date;
     }
-
     return new Intl.DateTimeFormat('default', {
         year: 'numeric',
         month: 'numeric',
@@ -4021,80 +3821,58 @@ function formatDate(date) {
         hour12: false
     }).format(parsed);
 }
-
 function formatTextAddress(address) {
-    return []
-        .concat(address.name || [])
-        .concat(address.name ? `<${address.address}>` : address.address)
-        .join(' ');
+    return (address.name ? [address.name, `<${address.address}>`] : [address.address]).join(' ');
 }
-
 function formatTextAddresses(addresses) {
     let parts = [];
-
     let processAddress = (address, partCounter) => {
         if (partCounter) {
             parts.push(', ');
         }
-
         if (address.group) {
             let groupStart = `${address.name}:`;
             let groupEnd = `;`;
-
             parts.push(groupStart);
             address.group.forEach(processAddress);
             parts.push(groupEnd);
-        } else {
+        }
+        else {
             parts.push(formatTextAddress(address));
         }
     };
-
     addresses.forEach(processAddress);
-
     return parts.join('');
 }
-
 function formatHtmlAddress(address) {
     return `<a href="mailto:${escapeHtml(address.address)}" class="postal-email-address">${escapeHtml(address.name || `<${address.address}>`)}</a>`;
 }
-
 function formatHtmlAddresses(addresses) {
     let parts = [];
-
     let processAddress = (address, partCounter) => {
         if (partCounter) {
             parts.push('<span class="postal-email-address-separator">, </span>');
         }
-
         if (address.group) {
             let groupStart = `<span class="postal-email-address-group">${escapeHtml(address.name)}:</span>`;
             let groupEnd = `<span class="postal-email-address-group">;</span>`;
-
             parts.push(groupStart);
             address.group.forEach(processAddress);
             parts.push(groupEnd);
-        } else {
+        }
+        else {
             parts.push(formatHtmlAddress(address));
         }
     };
-
     addresses.forEach(processAddress);
-
     return parts.join(' ');
 }
-
 function foldLines(str, lineLength, afterSpace) {
     str = (str || '').toString();
     lineLength = lineLength || 76;
-
-    let pos = 0,
-        len = str.length,
-        result = '',
-        line,
-        match;
-
+    let pos = 0, len = str.length, result = '', line, match;
     while (pos < len) {
-        line = str.substr(pos, lineLength);
+        line = str.slice(pos, pos + lineLength);
         if (line.length < lineLength) {
             result += line;
             break;
@@ -4104,54 +3882,44 @@ function foldLines(str, lineLength, afterSpace) {
             result += line;
             pos += line.length;
             continue;
-        } else if (
-            (match = line.match(/(\s+)[^\s]*$/)) &&
-            match[0].length - ((match[1] || '').length ) < line.length
-        ) {
-            line = line.substr(0, line.length - (match[0].length - ((match[1] || '').length )));
-        } else if ((match = str.substr(pos + line.length).match(/^[^\s]+(\s*)/))) {
-            line = line + match[0].substr(0, match[0].length - (0));
         }
-
+        else if ((match = line.match(/(\s+)[^\s]*$/)) &&
+            match[0].length - ((match[1] || '').length ) < line.length) {
+            line = line.slice(0, line.length - (match[0].length - ((match[1] || '').length )));
+        }
+        else if ((match = str.slice(pos + line.length).match(/^[^\s]+(\s*)/))) {
+            line = line + match[0].slice(0, match[0].length - (0));
+        }
         result += line;
         pos += line.length;
         if (pos < len) {
             result += '\r\n';
         }
     }
-
     return result;
 }
-
 function formatTextHeader(message) {
     let rows = [];
-
     if (message.from) {
         // through the plural formatter, because `From:` may hold RFC 5322 group syntax
         // and a group has no address of its own
         rows.push({ key: 'From', val: formatTextAddresses([message.from]) });
     }
-
     if (message.subject) {
         rows.push({ key: 'Subject', val: message.subject });
     }
-
     if (message.date) {
         rows.push({ key: 'Date', val: formatDate(message.date) });
     }
-
     if (message.to && message.to.length) {
         rows.push({ key: 'To', val: formatTextAddresses(message.to) });
     }
-
     if (message.cc && message.cc.length) {
         rows.push({ key: 'Cc', val: formatTextAddresses(message.cc) });
     }
-
     if (message.bcc && message.bcc.length) {
         rows.push({ key: 'Bcc', val: formatTextAddresses(message.bcc) });
     }
-
     // Align keys and values by adding space between these two
     // Also make sure that the separator line is as long as the longest line
     // Should end up with something like this:
@@ -4163,144 +3931,361 @@ function formatTextHeader(message) {
     To:      not@found.com
     -----------------------------
     */
-
     let maxKeyLength = rows
         .map(r => r.key.length)
         .reduce((acc, cur) => {
-            return cur > acc ? cur : acc;
-        }, 0);
-
-    rows = rows.flatMap(row => {
+        return cur > acc ? cur : acc;
+    }, 0);
+    const lines = rows.flatMap(row => {
         let sepLen = maxKeyLength - row.key.length;
         let prefix = `${row.key}: ${' '.repeat(sepLen)}`;
         let emptyPrefix = `${' '.repeat(row.key.length + 1)} ${' '.repeat(sepLen)}`;
-
         let foldedLines = foldLines(row.val, 80)
             .split(/\r?\n/)
             .map(line => line.trim());
-
         return foldedLines.map((line, i) => `${i ? emptyPrefix : prefix}${line}`);
     });
-
-    let maxLineLength = rows
+    let maxLineLength = lines
         .map(r => r.length)
         .reduce((acc, cur) => {
-            return cur > acc ? cur : acc;
-        }, 0);
-
+        return cur > acc ? cur : acc;
+    }, 0);
     let lineMarker = '-'.repeat(maxLineLength);
-
     let template = `
 ${lineMarker}
-${rows.join('\n')}
+${lines.join('\n')}
 ${lineMarker}
 `;
-
     return template;
 }
-
 function formatHtmlHeader(message) {
     let rows = [];
-
     if (message.from) {
         rows.push(
-            // through the plural formatter, because `From:` may hold RFC 5322 group syntax
-            // and a group has no address of its own
-            `<div class="postal-email-header-key">From</div><div class="postal-email-header-value">${formatHtmlAddresses([message.from])}</div>`
-        );
+        // through the plural formatter, because `From:` may hold RFC 5322 group syntax
+        // and a group has no address of its own
+        `<div class="postal-email-header-key">From</div><div class="postal-email-header-value">${formatHtmlAddresses([message.from])}</div>`);
     }
-
     if (message.subject) {
-        rows.push(
-            `<div class="postal-email-header-key">Subject</div><div class="postal-email-header-value postal-email-header-subject">${escapeHtml(
-                message.subject
-            )}</div>`
-        );
+        rows.push(`<div class="postal-email-header-key">Subject</div><div class="postal-email-header-value postal-email-header-subject">${escapeHtml(message.subject)}</div>`);
     }
-
     if (message.date) {
-        rows.push(
-            `<div class="postal-email-header-key">Date</div><div class="postal-email-header-value postal-email-header-date" data-date="${escapeHtml(
-                message.date
-            )}">${escapeHtml(formatDate(message.date))}</div>`
-        );
+        rows.push(`<div class="postal-email-header-key">Date</div><div class="postal-email-header-value postal-email-header-date" data-date="${escapeHtml(message.date)}">${escapeHtml(formatDate(message.date))}</div>`);
     }
-
     if (message.to && message.to.length) {
-        rows.push(
-            `<div class="postal-email-header-key">To</div><div class="postal-email-header-value">${formatHtmlAddresses(message.to)}</div>`
-        );
+        rows.push(`<div class="postal-email-header-key">To</div><div class="postal-email-header-value">${formatHtmlAddresses(message.to)}</div>`);
     }
-
     if (message.cc && message.cc.length) {
-        rows.push(
-            `<div class="postal-email-header-key">Cc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.cc)}</div>`
-        );
+        rows.push(`<div class="postal-email-header-key">Cc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.cc)}</div>`);
     }
-
     if (message.bcc && message.bcc.length) {
-        rows.push(
-            `<div class="postal-email-header-key">Bcc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.bcc)}</div>`
-        );
+        rows.push(`<div class="postal-email-header-key">Bcc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.bcc)}</div>`);
     }
-
-    let template = `<div class="postal-email-header">${rows.length ? '<div class="postal-email-header-row">' : ''}${rows.join(
-        '</div>\n<div class="postal-email-header-row">'
-    )}${rows.length ? '</div>' : ''}</div>`;
-
+    let template = `<div class="postal-email-header">${rows.length ? '<div class="postal-email-header-row">' : ''}${rows.join('</div>\n<div class="postal-email-header-row">')}${rows.length ? '</div>' : ''}</div>`;
     return template;
 }
 
-const WORD_CHAR_REGEX = /\w/;
-const NON_SPACE_TOKEN_REGEX = /[^\s]+/g;
-
 /**
- * Finds the first address looking token in a run of text.
+ * Any whitespace, the test for an angle-addr that needs recovering
+ */
+const HAS_WHITESPACE = /\s/;
+/**
+ * An addr-spec that carries its whitespace legally, inside a quoted local part. The
+ * optional tail is the malformed shape: a real mailbox with wreckage trailing it.
+ */
+const QUOTED_LOCAL_ADDR = /^("(?:[^"\\]|\\[\s\S])*"@\S+)(?:\s+([\s\S]+))?$/;
+/**
+ * One run holding a single '@' and no whitespace, the shape an addr-spec has to have
+ */
+const ADDR_SPEC = /^[^@\s]+@[^@\s]+$/;
+/**
+ * The looser reading applied once the strict one finds nothing, which tolerates the
+ * further '@' that a domain should not have but malformed headers carry anyway
+ */
+const LOOSE_ADDR_SPEC = /^[^@\s]+@\S+$/;
+/**
+ * An addr-spec sitting inside free text, together with the whitespace around it. Sticky
+ * on purpose: it is only run at the offset looseAddressStart picks, see there.
+ */
+const LOOSE_TEXT_ADDR = /\s*\b[^@\s]+@[^\s]+\b\s*/y;
+/**
+ * Restores the quoting of a local part that was read out of a quoted string.
  *
- * This replaces a `\s*\b[^@\s]+@[^\s]+\b\s*` scan over the whole string, which backtracks
- * quadratically: the leading `\s*` makes every position inside a whitespace run a viable
- * start, and `[^@\s]+` then gives back one character at a time looking for an '@'. A
- * single header well inside the default size limit could hold a core busy for minutes.
+ * RFC 5321 allows '@' inside a quoted local part, so handing '"user@evil.com"@good.com'
+ * on as the bare 'user@evil.com@good.com' leaves it to the consumer which '@' splits the
+ * domain off. Getting that wrong is a misrouting vector, so the quotes go back on. The
+ * same holds for the other specials: a ',' or a ';' that loses its quotes reads as a
+ * recipient separator once the consumer puts the address back into a header.
  *
- * Scanning whitespace delimited tokens instead is linear and keeps the word boundary
- * semantics of the regex: the local part has to open on a word character and the domain
- * has to end on one.
+ * @param address Address with an unquoted local part
+ * @return Address with the local part as a quoted-string
+ */
+function quoteLocalPart(address) {
+    const lastAt = address.lastIndexOf('@');
+    if (lastAt < 0) {
+        // no domain to split off, nothing can be misrouted
+        return address;
+    }
+    const user = address.substring(0, lastAt);
+    if (/^[^\s"(),:;<>@[\\\]]+$/.test(user) || /^"(?:[^"\\]|\\[\s\S])*"$/.test(user)) {
+        // a local part that carries no special reads the same with or without the quotes,
+        // and one that is already a complete quoted-string needs nothing either
+        return address;
+    }
+    return '"' + user.replace(/["\\]/g, '\\$&') + '"@' + address.substring(lastAt + 1);
+}
+/**
+ * The characters JS `\s` matches, which the scan below has to agree with to land on the
+ * same match LOOSE_TEXT_ADDR would.
+ */
+function isSpaceCode(code) {
+    return (code === 0x20 ||
+        (code >= 0x09 && code <= 0x0d) ||
+        code === 0xa0 ||
+        code === 0x1680 ||
+        (code >= 0x2000 && code <= 0x200a) ||
+        code === 0x2028 ||
+        code === 0x2029 ||
+        code === 0x202f ||
+        code === 0x205f ||
+        code === 0x3000 ||
+        code === 0xfeff);
+}
+/**
+ * The characters JS `\w` matches without the unicode flag, the set the `\b` in
+ * LOOSE_TEXT_ADDR is read against. charCodeAt off either end of the string gives NaN,
+ * which compares false throughout, so out of range reads as a non-word character.
+ */
+function isWordCode(code) {
+    return ((code >= 0x30 && code <= 0x39) ||
+        (code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        code === 0x5f);
+}
+/**
+ * Whether `\b` holds at an offset
+ */
+function isBoundary(text, at) {
+    return isWordCode(text.charCodeAt(at - 1)) !== isWordCode(text.charCodeAt(at));
+}
+/**
+ * Offset of the first '@' in `text` between `from` and `to`, or -1 when the range holds none.
+ * Bounded rather than indexOf, which would scan on to the end of the header once for every
+ * whitespace delimited run and make the walk below quadratic.
+ */
+function indexOfAt(text, from, to) {
+    for (let i = from; i < to; i++) {
+        if (text.charCodeAt(i) === 0x40) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Finds the offset LOOSE_TEXT_ADDR matches at, or -1 when it does not match at all.
+ *
+ * Letting the pattern search for itself is quadratic: '[^@\s]+' is retried from every
+ * offset and rescans the run to the next '@' each time, so a single header well inside
+ * the default size limit could hold a core busy for minutes. The search is also
+ * unnecessary. '[^@\s]+' crosses neither whitespace nor a '@', so a match can only begin
+ * at the head of a whitespace delimited run or just past a '@' inside one, and '[^\s]+\b'
+ * gives characters back until it lands on a boundary, so the only end it can take in that
+ * run is the last boundary in it. Both are found in one pass, and the pattern is then run
+ * at that single offset.
  *
- * @param {String} text Text to search
- * @return {Object|null} `{index, length, value}` of the address, or null if there is none
+ * @param text Free text to look in
+ * @return Offset to match at, or -1
  */
-function findAddressInText(text) {
-    NON_SPACE_TOKEN_REGEX.lastIndex = 0;
-
-    let match;
-    while ((match = NON_SPACE_TOKEN_REGEX.exec(text))) {
-        const token = match[0];
-        const at = token.indexOf('@');
-
-        // `\b[^@\s]+@` needs at least one character before the '@'
-        let start = 0;
-        while (start < at && !WORD_CHAR_REGEX.test(token.charAt(start))) {
-            start++;
+function looseAddressStart(text) {
+    const len = text.length;
+    let pos = 0;
+    while (pos < len) {
+        while (pos < len && isSpaceCode(text.charCodeAt(pos))) {
+            pos++;
+        }
+        if (pos >= len) {
+            break;
+        }
+        const runStart = pos;
+        let runEnd = pos;
+        while (runEnd < len && !isSpaceCode(text.charCodeAt(runEnd))) {
+            runEnd++;
+        }
+        let at = indexOfAt(text, runStart, runEnd);
+        if (at >= 0) {
+            let lastBoundary = -1;
+            for (let k = runEnd; k > runStart; k--) {
+                if (isBoundary(text, k)) {
+                    lastBoundary = k;
+                    break;
+                }
+            }
+            let atomStart = runStart;
+            while (lastBoundary >= 0 && at >= 0) {
+                // '[^@\s]+' has to cover a character before the '@' and '[^\s]+' one after it,
+                // and the boundary that ends the match has to sit past both
+                if (at > atomStart && runEnd > at + 1 && lastBoundary > at + 1) {
+                    for (let start = atomStart; start < at; start++) {
+                        if (isBoundary(text, start)) {
+                            if (start > runStart) {
+                                return start;
+                            }
+                            // the leading '\s*' is greedy, so a match that begins at the run
+                            // takes the whitespace in front of it along
+                            let padded = runStart;
+                            while (padded > 0 && isSpaceCode(text.charCodeAt(padded - 1))) {
+                                padded--;
+                            }
+                            return padded;
+                        }
+                    }
+                }
+                atomStart = at + 1;
+                at = indexOfAt(text, atomStart, runEnd);
+            }
+        }
+        pos = runEnd;
+    }
+    return -1;
+}
+/**
+ * Recovers the addr-spec from an angle-addr that came back holding unquoted whitespace.
+ *
+ * A malformed header can put more than a mailbox between the angle brackets, most often
+ * because the generator wrote the recipient twice: '<user@example.com user@example.com>'
+ * or '<example.com user@example.com>'. Whitespace is not addr-spec, so the whole run can
+ * never be a mailbox, and passing it on as the address loses the recipient that is
+ * sitting right there in the header.
+ *
+ * The run that still reads as an addr-spec is kept and whatever is left over becomes
+ * display text. Candidates are read strictly first and then under the looser grammar,
+ * the same two tiers the unquoted text fallback applies, so that '<a@b@c.com junk>' and a
+ * bare 'a@b@c.com junk' agree on the recipient.
+ *
+ * A quoted local part is left alone: RFC 5321 allows whitespace inside it, so
+ * '<"user name"@example.com>' is well formed and means exactly what it says.
+ *
+ * @param address Collected address
+ * @param text Collected display text
+ * @return The address and the display text, with any leftovers moved to the text
+ */
+function recoverAddrSpec(address, text) {
+    if (!HAS_WHITESPACE.test(address)) {
+        return { address, text };
+    }
+    let rest;
+    const quoted = address.match(QUOTED_LOCAL_ADDR);
+    if (quoted) {
+        if (!quoted[2]) {
+            // the whitespace sits inside the quoted local part, this is a well formed mailbox
+            return { address, text };
         }
-        if (start >= at) {
+        // a real mailbox with wreckage trailing it, so peel the addr-spec off whole rather
+        // than splitting into the quotes
+        address = quoted[1];
+        rest = [quoted[2]];
+    }
+    else {
+        if (address.indexOf('"') >= 0) {
+            // Splitting on whitespace loses track of where a quoted string starts and ends,
+            // and addresses are never taken out of quoted strings: the run picked out of
+            // '<junk "user@evil.com b"@good.com>' would be an address from the domain the
+            // quotes were hiding. Every well formed shape was handled above, so the original
+            // is the honest answer
+            return { address, text };
+        }
+        const parts = address.split(/\s+/);
+        let addrIndex = parts.findIndex(part => ADDR_SPEC.test(part));
+        if (addrIndex < 0) {
+            addrIndex = parts.findIndex(part => LOOSE_ADDR_SPEC.test(part));
+        }
+        if (addrIndex < 0) {
+            // nothing in there reads as an address, there is no better answer than the original
+            return { address, text };
+        }
+        address = parts.splice(addrIndex, 1)[0];
+        rest = parts;
+    }
+    return {
+        address,
+        text: [text, ...rest].filter(part => part).join(' ')
+    };
+}
+/**
+ * Takes the RFC 5322 comments out of the contents of an angle-addr.
+ *
+ * The tokenizer tracks a single open operator, so once '<' is open a '(' is plain text and
+ * a comment inside the brackets reached the address verbatim: 'Name <user@example.com(x)evil.com>'
+ * put 'user@example.com(x)evil.com' into the address, a value that is no mailbox and that a
+ * consumer stripping the comment reads as 'user@example.comevil.com'. A comment is folding
+ * whitespace, so it is read as a space that splits two atoms and as nothing next to an '@',
+ * the same rule the token walk applies outside the brackets. Quoted strings and domain
+ * literals are copied through untouched, a '(' in there is not a comment.
+ *
+ * @param address Contents of the angle brackets
+ * @return The address with the comments removed, and the text of the comments
+ */
+function stripAddressComments(address) {
+    const comments = [];
+    let result = '';
+    let comment = '';
+    let depth = 0;
+    let closer = '';
+    // carried along rather than read back off the growing result, which would flatten it on
+    // every comment (see lastChars in _handleAddress)
+    let lastChar = '';
+    for (let i = 0, len = address.length; i < len; i++) {
+        const chr = address.charAt(i);
+        if (depth) {
+            if (chr === '\\' && i < len - 1) {
+                comment += address.charAt(++i);
+            }
+            else if (chr === '(') {
+                depth++;
+                comment += chr;
+            }
+            else if (chr === ')' && !--depth) {
+                comments.push(comment.trim());
+                comment = '';
+                if (lastChar !== '@' && address.charAt(i + 1) !== '@') {
+                    result += ' ';
+                    lastChar = ' ';
+                }
+            }
+            else {
+                comment += chr;
+            }
             continue;
         }
-
-        // `[^\s]+\b` needs at least one character after the '@', ending on a word character
-        let end = token.length;
-        while (end > at + 1 && !WORD_CHAR_REGEX.test(token.charAt(end - 1))) {
-            end--;
+        if (closer) {
+            if (chr === '\\' && closer === '"' && i < len - 1) {
+                result += chr + address.charAt(++i);
+                lastChar = address.charAt(i);
+                continue;
+            }
+            if (chr === closer) {
+                closer = '';
+            }
+        }
+        else if (chr === '"') {
+            closer = '"';
+        }
+        else if (chr === '[') {
+            closer = ']';
         }
-        if (end <= at + 1) {
+        else if (chr === '(') {
+            depth = 1;
             continue;
         }
-
-        return { index: match.index + start, length: end - start, value: token.substring(start, end) };
+        result += chr;
+        lastChar = chr;
     }
-
-    return null;
+    if (depth) {
+        // an unterminated comment runs to the end of the address
+        comments.push(comment.trim());
+    }
+    return { address: result.trim(), comments: comments.filter(text => text) };
 }
-
 /**
  * Checks whether text holds an angle bracket address, ie. `<` and `>` around a run
  * without other angle brackets that has an '@' with at least one character on each side.
@@ -4308,45 +4293,43 @@ function findAddressInText(text) {
  * Same answer as `/<[^<>]+@[^<>]+>/.test(text)`, which backtracks quadratically on a `<`
  * followed by a long run of '@' and no closing `>`.
  *
- * @param {String} text Text to check
- * @return {Boolean} true if an angle bracket address is present
+ * @param text Text to check
+ * @return true if an angle bracket address is present
  */
 function hasAngleAddress(text) {
     // position right after the `<` that opened the current bracket, or -1
     let start = -1;
     // first '@' inside the bracket that has a character before it, or -1
     let at = -1;
-
     for (let i = 0; i < text.length; i++) {
         const chr = text.charAt(i);
         if (chr === '<') {
             start = i + 1;
             at = -1;
-        } else if (chr === '>') {
+        }
+        else if (chr === '>') {
             if (at >= 0 && at < i - 1) {
                 return true;
             }
             start = -1;
             at = -1;
-        } else if (chr === '@' && start >= 0 && at < 0 && i > start) {
+        }
+        else if (chr === '@' && start >= 0 && at < 0 && i > start) {
             at = i;
         }
     }
-
     return false;
 }
-
 /**
  * Converts tokens for a single address into an address object
  *
- * @param {Array} tokens Tokens object
- * @param {Number} depth Current recursion depth for nested group protection
- * @return {Object} Address object
+ * @param tokens Tokens object
+ * @param depth Current recursion depth for nested group protection
+ * @return Address objects
  */
 function _handleAddress(tokens, depth) {
     let isGroup = false;
     let state = 'text';
-    let address;
     let addresses = [];
     let data = {
         address: [],
@@ -4358,7 +4341,11 @@ function _handleAddress(tokens, depth) {
     let i;
     let len;
     let insideQuotes = false; // Track if we're currently inside a quoted string
-
+    // Last character of the run each state is currently accumulating. Reading it back off
+    // the accumulator with slice(-1) makes the engine flatten the whole growing string on
+    // every token, which is quadratic over an address built from many comment-joined atoms.
+    // A run only ever grows by the token appended below, so the character is carried along.
+    const lastChars = { address: '', comment: '', group: '', text: '' };
     // Filter out <addresses>, (comments) and regular text
     for (i = 0, len = tokens.length; i < len; i++) {
         let token = tokens[i];
@@ -4388,43 +4375,61 @@ function _handleAddress(tokens, depth) {
                     insideQuotes = false;
                     break;
             }
-        } else if (token.value) {
+        }
+        else if (token.value) {
+            // An empty quoted string is dropped by the tokenizer, leaving no text token of its
+            // own to record the quoting on, so the pair of quote operators right in front of
+            // this token is all that is left of it and the run it opens carries the quoting
+            // instead. Without this '""@example.com' reads as the bare '@example.com'. It only
+            // ever opens a run: a run already holding unquoted text is not a quoted string
+            const prevPrevToken = i > 1 ? tokens[i - 2] : null;
+            const opensAfterEmptyQuotedString = prevToken?.type === 'operator' &&
+                prevToken.value === '"' &&
+                !!prevToken.noBreak &&
+                prevPrevToken?.type === 'operator' &&
+                prevPrevToken.value === '"';
             if (state === 'address') {
                 // handle use case where unquoted name includes a "<"
                 // Apple Mail truncates everything between an unexpected < and an address
                 // and so will we
                 token.value = token.value.replace(/^[^<]*<\s*/, '');
             }
-
-            if (prevToken && prevToken.noBreak && data[state].length) {
+            // A comment is folding whitespace. It may sit inside an addr-spec, on either side
+            // of the '@', but it cannot join two atoms into one: gluing across it would read
+            // 'user@example.com(x)evil.com' as the single domain 'example.comevil.com' and
+            // name a domain the sender never wrote.
+            const joins = prevToken &&
+                prevToken.noBreak &&
+                data[state].length &&
+                (prevToken.value !== ')' || lastChars[state] === '@' || token.value.charAt(0) === '@');
+            if (joins) {
                 // join values
                 data[state][data[state].length - 1] += token.value;
                 if (state === 'text' && insideQuotes) {
                     data.textWasQuoted[data.textWasQuoted.length - 1] = true;
                 }
-            } else {
+            }
+            else {
                 data[state].push(token.value);
                 if (state === 'text') {
-                    data.textWasQuoted.push(insideQuotes);
+                    data.textWasQuoted.push(insideQuotes || opensAfterEmptyQuotedString);
                 }
             }
+            lastChars[state] = token.value.charAt(token.value.length - 1);
         }
     }
-
     // If there is no text but a comment, replace the two
     if (!data.text.length && data.comment.length) {
         data.text = data.comment;
         data.comment = [];
     }
-
     if (isGroup) {
         // http://tools.ietf.org/html/rfc2822#appendix-A.1.3
-        data.text = data.text.join(' ');
-
+        const text = data.text.join(' ');
         // Parse group members, but flatten any nested groups (RFC 5322 doesn't allow nesting)
         let groupMembers = [];
         if (data.group.length) {
-            let parsedGroup = addressParser(data.group.join(','), { _depth: depth + 1 });
+            let parsedGroup = parseAddressList(data.group.join(','), depth + 1);
             // Flatten: if any member is itself a group, extract its members into the sequence
             parsedGroup.forEach(member => {
                 if (member.group) {
@@ -4432,126 +4437,161 @@ function _handleAddress(tokens, depth) {
                     for (const nestedMember of member.group) {
                         groupMembers.push(nestedMember);
                     }
-                } else {
+                }
+                else {
                     groupMembers.push(member);
                 }
             });
         }
-
         addresses.push({
-            name: decodeWords(data.text || (address && address.name)),
+            name: decodeWords(text),
             group: groupMembers
         });
-    } else {
+    }
+    else {
+        // Comments come out of the angle-addr before anything asks whether one was found, so
+        // that brackets holding nothing but a comment read the same as empty ones
+        const addressComments = [];
+        const addressParts = [];
+        for (const part of data.address) {
+            if (part.indexOf('(') < 0) {
+                addressParts.push(part);
+                continue;
+            }
+            const stripped = stripAddressComments(part);
+            for (const comment of stripped.comments) {
+                addressComments.push(comment);
+            }
+            if (stripped.address) {
+                addressParts.push(stripped.address);
+            }
+        }
+        data.address = addressParts;
         // If no address was found, try to detect one from regular text
         if (!data.address.length && data.text.length) {
             for (i = data.text.length - 1; i >= 0; i--) {
                 // Security fix: Do not extract email addresses from quoted strings
                 // RFC 5321 allows @ inside quoted local-parts like "user@domain"@example.com
                 // Extracting emails from quoted text leads to misrouting vulnerabilities
-                if (!data.textWasQuoted[i] && data.text[i].match(/^[^@\s]+@[^@\s]+$/)) {
+                if (!data.textWasQuoted[i] && ADDR_SPEC.test(data.text[i])) {
                     data.address = data.text.splice(i, 1);
                     data.textWasQuoted.splice(i, 1);
                     break;
                 }
             }
-
             // still no address
             if (!data.address.length) {
                 for (i = data.text.length - 1; i >= 0; i--) {
                     // Security fix: Do not extract email addresses from quoted strings
                     if (!data.textWasQuoted[i]) {
                         // handles an email address that has more than one @
-                        const found = findAddressInText(data.text[i]);
-                        if (found) {
-                            data.address = [found.value];
-                            // the address and the whitespace around it collapse to one space.
-                            // trimEnd rather than `/\s+$/`, which retries at every position of
-                            // a whitespace run that is not at the end and is quadratic in it.
-                            data.text[i] = (
-                                data.text[i].substring(0, found.index).trimEnd() +
-                                ' ' +
-                                data.text[i].substring(found.index + found.length).trimStart()
-                            ).trim();
-                            break;
+                        const part = data.text[i];
+                        const start = looseAddressStart(part);
+                        if (start >= 0) {
+                            LOOSE_TEXT_ADDR.lastIndex = start;
+                            const match = LOOSE_TEXT_ADDR.exec(part);
+                            if (match) {
+                                data.address = [match[0].trim()];
+                                // the match takes the whitespace around the address along, so
+                                // the text on either side is joined with a single space
+                                data.text[i] = (part.slice(0, start) +
+                                    ' ' +
+                                    part.slice(start + match[0].length)).trim();
+                                break;
+                            }
                         }
-                        data.text[i] = data.text[i].trim();
+                        data.text[i] = part.trim();
                     }
                 }
             }
         }
-
         // If there's still no text but a comment exists, replace the two
         if (!data.text.length && data.comment.length) {
             data.text = data.comment;
             data.comment = [];
         }
-
         // Keep only the first address occurrence, push others to regular text
         if (data.address.length > 1) {
             data.text = data.text.concat(data.address.splice(1));
         }
-
+        // An address is only taken from unquoted text, so anything left in the text at this
+        // point that still has to serve as the address carries its quoting in this flag
+        const addressFromQuotedText = !data.address.length && data.textWasQuoted.some(wasQuoted => wasQuoted);
         // Join values with spaces
-        data.text = data.text.join(' ');
-        data.address = data.address.join(' ');
-
+        let text = data.text.join(' ');
+        let addressValue = data.address.join(' ');
         // `^=\?[^=]+?=$` could not match a base64 word whose padding puts an '=' inside it,
         // so whether a bare encoded word was decoded or left to become the address itself
         // came down to whether its payload happened to need padding.
-        if (!data.address && isEncodedWordsOnly(data.text.trim())) {
+        if (!addressValue && isEncodedWordsOnly(text.trim())) {
             // try to extract words from text content
-            const decodedText = decodeWords(data.text);
+            const decodedText = decodeWords(text);
             // Security: only re-parse if decoded text contains angle-bracket addresses.
             // Without this, a bare encoded email (e.g. =?utf-8?B?dGVzdEBldmlsLmNv?=)
-            // would be fabricated into an address from attacker-controlled input.
-            if (hasAngleAddress(decodedText)) {
-                const parsedSubAddresses = addressParser(decodedText);
-                if (parsedSubAddresses && parsedSubAddresses.length) {
+            // would be fabricated into an address from attacker-controlled input. A quoted
+            // encoded word is never re-parsed, addresses are not taken out of quoted strings
+            if (!addressFromQuotedText && hasAngleAddress(decodedText)) {
+                const parsedSubAddresses = parseAddressList(decodedText, depth + 1);
+                if (parsedSubAddresses.length) {
                     return parsedSubAddresses;
                 }
             }
             // No usable address found - treat decoded text as display name only
             return [{ address: '', name: decodedText }];
         }
-
-        address = {
-            address: data.address || data.text || '',
-            name: decodeWords(data.text || data.address || '')
+        if (addressFromQuotedText && text.indexOf('@') >= 0) {
+            // The mailbox is still sitting in the text, so it moves over here and is quoted
+            // before the recovery below rather than after it. Anything else the text holds
+            // came along with it: a comment ends the domain but leaves the atoms behind it in
+            // the same text, so '"user"@example.com(x)evil.com' would otherwise hand on
+            // 'user@example.com evil.com', a second domain riding along in a value that is no
+            // addr-spec at all. Putting the quotes back first is what lets the recovery tell
+            // the whitespace a quoted local part may carry from the wreckage trailing one
+            addressValue = quoteLocalPart(text);
+            text = '';
+        }
+        ({ address: addressValue, text } = recoverAddrSpec(addressValue, text));
+        // a comment names the mailbox only when nothing else does, as one outside the brackets
+        if (!text && addressComments.length) {
+            text = addressComments.join(' ');
+        }
+        const rawName = text || addressValue || '';
+        const address = {
+            address: addressValue || text || '',
+            name: decodeWords(rawName)
         };
-
-        if (address.address === address.name) {
-            if ((address.address || '').match(/@/)) {
+        // The raw comparison is the check Nodemailer makes, it holds when a single source
+        // filled both fields. The decoded one is added because postal-mime decodes names,
+        // which also catches a name that decodes to the address itself. Comparing only the
+        // decoded name kept a name that mixes an encoded word with plain text as the address
+        if (address.address === rawName || address.address === address.name) {
+            if (address.address.match(/@/)) {
                 address.name = '';
-            } else {
+            }
+            else {
                 address.address = '';
             }
         }
-
         addresses.push(address);
     }
-
     return addresses;
 }
-
 /**
- * Creates a Tokenizer object for tokenizing address field strings
- *
- * @constructor
- * @param {String} str Address field string
+ * Tokenizer for address field strings
  */
 class Tokenizer {
+    /**
+     * @param str Address field string
+     */
     constructor(str) {
         this.str = (str || '').toString();
         this.operatorCurrent = '';
         this.operatorExpecting = '';
         this.node = null;
         this.escaped = false;
-
+        this.inDomainLiteral = false;
+        this.afterAt = false;
         this.list = [];
-        /**
-         * Operator tokens and which tokens are expected to end the sequence
-         */
         this.operators = {
             '"': '"',
             '(': ')',
@@ -4567,68 +4607,89 @@ class Tokenizer {
             ';': ''
         };
     }
-
     /**
      * Tokenizes the original input string
      *
-     * @return {Array} An array of operator|text tokens
+     * @return An array of operator|text tokens
      */
     tokenize() {
         let list = [];
-
         for (let i = 0, len = this.str.length; i < len; i++) {
             let chr = this.str.charAt(i);
             let nextChr = i < len - 1 ? this.str.charAt(i + 1) : null;
             this.checkChar(chr, nextChr);
         }
-
         this.list.forEach(node => {
             node.value = (node.value || '').toString().trim();
             if (node.value) {
                 list.push(node);
             }
         });
-
         return list;
     }
-
     /**
      * Checks if a character is an operator or text and acts accordingly
      *
-     * @param {String} chr Character from the address field
+     * @param chr Character from the address field
+     * @param nextChr The character that follows, or null at the end of the field
      */
     checkChar(chr, nextChr) {
-        if (this.escaped) ; else if (chr === this.operatorExpecting) {
+        // Track RFC 5322 domain-literals ("[" *dtext "]"). The ":" of an IPv6 address-literal
+        // (user@[IPv6:2001:db8::1]) is dtext and must not be read as the group delimiter while
+        // inside the brackets. That is the only operator the literal hides: letting it hide
+        // the others as well meant a "[" could turn the comment, quoted string or angle-addr
+        // after it into text and pick a different mailbox, '[ ( ] <a@victim.com> ) <b@evil.com>'
+        // yielded a@victim.com where RFC 5322 reads b@evil.com. A "[" also only opens a literal
+        // right after the "@" of an addr-spec, so the group delimiter of a display name
+        // holding one stays intact. Quoted strings and comments are handled via
+        // operatorExpecting, so this state is only entered when no operator is open. The list
+        // separators "," and ";" always end the literal, so that an unclosed "[" can not
+        // swallow later recipients.
+        if (!this.escaped && !this.operatorExpecting) {
+            if (!this.inDomainLiteral && chr === '[' && this.afterAt) {
+                this.inDomainLiteral = true;
+            }
+            else if (this.inDomainLiteral && (chr === ']' || chr === ',' || chr === ';')) {
+                this.inDomainLiteral = false;
+            }
+        }
+        if (this.escaped) ;
+        else if (chr === this.operatorExpecting) {
             this.node = {
                 type: 'operator',
                 value: chr
             };
-
             if (nextChr && ![' ', '\t', '\r', '\n', ',', ';'].includes(nextChr)) {
                 this.node.noBreak = true;
             }
-
             this.list.push(this.node);
             this.node = null;
+            if (chr !== ')') {
+                // a comment is folding whitespace, it does not part the "@" from the "["
+                this.afterAt = false;
+            }
             this.operatorExpecting = '';
             this.escaped = false;
-
             return;
-        } else if (!this.operatorExpecting && chr in this.operators) {
+        }
+        else if (!this.operatorExpecting && !(this.inDomainLiteral && chr === ':') && chr in this.operators) {
             this.node = {
                 type: 'operator',
                 value: chr
             };
             this.list.push(this.node);
             this.node = null;
+            if (chr !== '(') {
+                this.afterAt = false;
+            }
             this.operatorExpecting = this.operators[chr];
             this.escaped = false;
             return;
-        } else if (this.operatorExpecting === '"' && chr === '\\') {
+        }
+        else if (this.operatorExpecting === '"' && chr === '\\') {
             this.escaped = true;
             return;
         }
-
         if (!this.node) {
             this.node = {
                 type: 'text',
@@ -4636,76 +4697,62 @@ class Tokenizer {
             };
             this.list.push(this.node);
         }
-
         if (chr === '\n') {
             // Convert newlines to spaces. Carriage return is ignored as \r and \n usually
             // go together anyway and there already is a WS for \n. Lone \r means something is fishy.
             chr = ' ';
         }
-
         if (chr.charCodeAt(0) >= 0x21 || [' ', '\t'].includes(chr)) {
             // skip command bytes
             this.node.value += chr;
+            // text inside a quoted string or a comment is not part of an addr-spec. Tracked
+            // as it goes rather than read back off the value (see lastChars in _handleAddress)
+            if (!this.operatorExpecting && chr !== ' ' && chr !== '\t') {
+                this.afterAt = chr === '@';
+            }
         }
-
         this.escaped = false;
     }
 }
-
 /**
  * Maximum recursion depth for parsing nested groups.
  * RFC 5322 doesn't allow nested groups, so this is a safeguard against
  * malicious input that could cause stack overflow.
  */
 const MAX_NESTED_GROUP_DEPTH = 50;
-
 /**
- * Parses structured e-mail addresses from an address field
- *
- * Example:
- *
- *    'Name <address@domain>'
- *
- * will be converted to
+ * Parses an address list, recursing into groups. The depth is threaded through the
+ * calls rather than taken from an option, so a caller supplied options object can not
+ * seed it and lift the recursion limit.
  *
- *     [{name: 'Name', address: 'address@domain'}]
- *
- * @param {String} str Address field
- * @param {Object} options Optional options object
- * @param {Number} options._depth Internal recursion depth counter (do not set manually)
- * @return {Array} An array of address objects
+ * @param str Address field
+ * @param depth Current recursion depth for nested group protection
+ * @return An array of address objects
  */
-function addressParser(str, options) {
-    options = options || {};
-    let depth = options._depth || 0;
-
+function parseAddressList(str, depth) {
     // Prevent stack overflow from deeply nested groups (DoS protection)
     if (depth > MAX_NESTED_GROUP_DEPTH) {
         return [];
     }
-
     let tokenizer = new Tokenizer(str);
     let tokens = tokenizer.tokenize();
-
     let addresses = [];
     let address = [];
     const parsedAddresses = [];
-
     tokens.forEach(token => {
         if (token.type === 'operator' && (token.value === ',' || token.value === ';')) {
             if (address.length) {
                 addresses.push(address);
             }
             address = [];
-        } else {
+        }
+        else {
             address.push(token);
         }
     });
-
     if (address.length) {
         addresses.push(address);
     }
-
     // Appended in place. Rebuilding the list with concat() for every address copies
     // everything parsed so far and is quadratic in the number of addresses.
     for (const tokens of addresses) {
@@ -4713,31 +4760,49 @@ function addressParser(str, options) {
             parsedAddresses.push(address);
         }
     }
-
-    if (options.flatten) {
-        let addresses = [];
-        let walkAddressList = list => {
-            list.forEach(address => {
-                if (address.group) {
-                    return walkAddressList(address.group);
-                } else {
-                    addresses.push(address);
-                }
-            });
-        };
-        walkAddressList(parsedAddresses);
-        return addresses;
+    // Merge fragments produced when unquoted display names contain commas.
+    // "Joe Foo, PhD <joe@example.com>" is split on the comma into
+    // [{name:"Joe Foo", address:""}, {name:"PhD", address:"joe@example.com"}].
+    // Recombine: a name-only entry followed by an entry with both name and address.
+    // Walked back to front so that a run of fragments folds into one entry in a single
+    // pass. Splicing each fragment out of the list instead would be quadratic.
+    const mergedAddresses = [];
+    for (let i = parsedAddresses.length - 1; i >= 0; i--) {
+        const current = parsedAddresses[i];
+        const next = mergedAddresses.length ? mergedAddresses[mergedAddresses.length - 1] : null;
+        if (next && current.address === '' && current.name && !current.group && next.address && next.name) {
+            next.name = current.name + ', ' + next.name;
+        }
+        else {
+            mergedAddresses.push(current);
+        }
     }
-
+    return mergedAddresses.reverse();
+}
+/**
+ * Parses structured e-mail addresses from an address field
+ *
+ * Example:
+ *
+ *    'Name <address@domain>'
+ *
+ * will be converted to
+ *
+ *     [{name: 'Name', address: 'address@domain'}]
+ *
+ * @param str Address field
+ * @param options Optional options object
+ * @return An array of address objects
+ */
+function addressParser(str, options) {
+    const parsedAddresses = parseAddressList(str, 0);
     return parsedAddresses;
 }
 
 // Code from: https://gist.githubusercontent.com/jonleighton/958841/raw/fb05a8632efb75d85d43deb593df04367ce48371/base64ArrayBuffer.js
-
 // Converts an ArrayBuffer directly to base64, without any intermediate 'convert to string then
 // use window.btoa' step. According to my tests, this appears to be a faster approach:
 // http://jsperf.com/encoding-xhr-image-data/5
-
 /*
 MIT LICENSE
 
@@ -4749,59 +4814,63 @@ The above copyright notice and this permission notice shall be included in all c
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-
 function base64ArrayBuffer(arrayBuffer) {
-    var base64 = '';
-    var encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-    var bytes = new Uint8Array(arrayBuffer);
-    var byteLength = bytes.byteLength;
-    var byteRemainder = byteLength % 3;
-    var mainLength = byteLength - byteRemainder;
-
-    var a, b, c, d;
-    var chunk;
-
+    let base64 = '';
+    const encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const bytes = new Uint8Array(arrayBuffer);
+    const byteLength = bytes.byteLength;
+    const byteRemainder = byteLength % 3;
+    const mainLength = byteLength - byteRemainder;
+    let a, b, c, d;
+    let chunk;
     // Main loop deals with bytes in chunks of 3
-    for (var i = 0; i < mainLength; i = i + 3) {
+    for (let i = 0; i < mainLength; i = i + 3) {
         // Combine the three bytes into a single integer
         chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
-
         // Use bitmasks to extract 6-bit segments from the triplet
         a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
         b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
         c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
         d = chunk & 63; // 63       = 2^6 - 1
-
         // Convert the raw binary segments to the appropriate ASCII encoding
         base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
     }
-
     // Deal with the remaining bytes and padding
-    if (byteRemainder == 1) {
+    if (byteRemainder === 1) {
         chunk = bytes[mainLength];
-
         a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
-
         // Set the 4 least significant bits to zero
         b = (chunk & 3) << 4; // 3   = 2^2 - 1
-
         base64 += encodings[a] + encodings[b] + '==';
-    } else if (byteRemainder == 2) {
+    }
+    else if (byteRemainder === 2) {
         chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
-
         a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
         b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
-
         // Set the 2 least significant bits to zero
         c = (chunk & 15) << 2; // 15    = 2^4 - 1
-
         base64 += encodings[a] + encodings[b] + encodings[c] + '=';
     }
-
     return base64;
 }
 
+function isReadableStream(value) {
+    return !!value && typeof value.getReader === 'function';
+}
+function isBlob(value) {
+    return value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]';
+}
+// Renders one entry of a node as the requested text type. A text part of the other type
+// is converted, and a nested message becomes a header block in that format
+function renderEntry(textEntry, textType, convert) {
+    if (textEntry.type === 'subMessage') {
+        return textType === 'html' ? formatHtmlHeader(textEntry.value) : formatTextHeader(textEntry.value);
+    }
+    if (!convert) {
+        return textEntry.value;
+    }
+    return textType === 'html' ? textToHtml(textEntry.value) : htmlToText(textEntry.value);
+}
 const MAX_NESTING_DEPTH = 256;
 const MAX_HEADERS_SIZE = 2 * 1024 * 1024;
 // Inline message/rfc822 parts are parsed recursively. Without a dedicated limit
@@ -4809,11 +4878,6 @@ const MAX_HEADERS_SIZE = 2 * 1024 * 1024;
 // so a small crafted email can exhaust memory (OOM crash). Cap the recursion and
 // treat deeper nested messages as regular attachments instead.
 const MAX_RFC822_NESTING_DEPTH = 10;
-
-function toCamelCase(key) {
-    return key.replace(/-(.)/g, (o, c) => c.toUpperCase());
-}
-
 // Limit options must be validated rather than falsy-coalesced. `0` would silently
 // restore the default, and a string or NaN disables the limit altogether, because
 // every `size > limit` comparison against such a value is false. Callers that
@@ -4823,82 +4887,75 @@ function parseLimitOption(value, defaultValue, name) {
     if (value === undefined || value === null) {
         return defaultValue;
     }
-
     if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
         throw new TypeError(`${name} must be a non-negative integer`);
     }
-
     return value;
 }
-
 class PostalMime {
+    /**
+     * Parses a raw email message
+     *
+     * @param buf Raw email message
+     * @param options Parser options
+     * @returns The parsed email
+     */
     // async so that an invalid option rejects the returned promise instead of throwing
     // synchronously, which would escape a `.catch()` chain
     static async parse(buf, options) {
         const parser = new PostalMime(options);
         return parser.parse(buf);
     }
-
-    // rfc822NestingDepth is internal state that nested parsers receive from their parent.
-    // It is deliberately a separate argument rather than an option, so that forwarding a
-    // caller supplied options object can not seed it and switch the recursion limit off.
-    constructor(options, rfc822NestingDepth = 0) {
+    constructor(options) {
         this.options = options || {};
         this.mimeOptions = {
             maxNestingDepth: parseLimitOption(this.options.maxNestingDepth, MAX_NESTING_DEPTH, 'maxNestingDepth'),
             maxHeadersSize: parseLimitOption(this.options.maxHeadersSize, MAX_HEADERS_SIZE, 'maxHeadersSize')
         };
-
         // A limit of 0 disables inline parsing entirely, so every message/rfc822 part
         // becomes an attachment.
-        this.maxRfc822NestingDepth = parseLimitOption(
-            this.options.maxRfc822NestingDepth,
-            MAX_RFC822_NESTING_DEPTH,
-            'maxRfc822NestingDepth'
-        );
-        this.rfc822NestingDepth = rfc822NestingDepth;
-
+        this.maxRfc822NestingDepth = parseLimitOption(this.options.maxRfc822NestingDepth, MAX_RFC822_NESTING_DEPTH, 'maxRfc822NestingDepth');
+        // Internal state that a nested parser receives from its parent, see collectSubMessage.
+        // It is deliberately not an option, so that forwarding a caller supplied options
+        // object can not seed it and switch the recursion limit off.
+        this.rfc822NestingDepth = 0;
         this.root = this.currentNode = new MimeNode({
             postalMime: this,
             ...this.mimeOptions
         });
         this.boundaries = [];
-
         // Header bytes seen across every part of this message, see MimeNode.feed
         this.headerSize = 0;
-
         this.textContent = {};
+        this.textMap = new Map();
+        this.textTypes = new Set();
         this.attachments = [];
-
+        this.forceRfc822Attachments = false;
         this.attachmentEncoding =
             (this.options.attachmentEncoding || '')
                 .toString()
                 .replace(/[-_\s]/g, '')
                 .trim()
                 .toLowerCase() || 'arraybuffer';
-
         this.started = false;
     }
-
+    /** @internal */
     async finalize() {
         // close all pending nodes
         await this.root.finalize();
     }
-
+    /** @internal */
     async processLine(line, isFinal) {
         let boundaries = this.boundaries;
-
         // check if this is a mime boundary
         if (boundaries.length && line.length > 2 && line[0] === 0x2d && line[1] === 0x2d) {
             // could be a boundary marker
             for (let i = boundaries.length - 1; i >= 0; i--) {
                 let boundary = boundaries[i];
-
                 // Line must be at least long enough for "--" + boundary
                 if (line.length < boundary.value.length + 2) {
                     continue;
                 }
-
                 // Check if boundary value matches
                 let boundaryMatches = true;
                 for (let j = 0; j < boundary.value.length; j++) {
@@ -4910,20 +4967,15 @@ class PostalMime {
                 if (!boundaryMatches) {
                     continue;
                 }
-
                 // Check for terminator (-- after boundary) and determine where boundary ends
                 let boundaryEnd = boundary.value.length + 2;
                 let isTerminator = false;
-
-                if (
-                    line.length >= boundary.value.length + 4 &&
+                if (line.length >= boundary.value.length + 4 &&
                     line[boundary.value.length + 2] === 0x2d &&
-                    line[boundary.value.length + 3] === 0x2d
-                ) {
+                    line[boundary.value.length + 3] === 0x2d) {
                     isTerminator = true;
                     boundaryEnd = boundary.value.length + 4;
                 }
-
                 // RFC 2046: boundary line may have trailing whitespace (space/tab) before CRLF
                 let hasValidTrailing = true;
                 for (let j = boundaryEnd; j < line.length; j++) {
@@ -4935,15 +4987,13 @@ class PostalMime {
                 if (!hasValidTrailing) {
                     continue;
                 }
-
                 if (isTerminator) {
                     await boundary.node.finalize();
-
                     this.currentNode = boundary.node.parentNode || this.root;
-                } else {
+                }
+                else {
                     // finalize any open child nodes (should be just one though)
                     await boundary.node.finalizeChildNodes();
-
                     this.currentNode = new MimeNode({
                         postalMime: this,
                         parentNode: boundary.node,
@@ -4951,33 +5001,26 @@ class PostalMime {
                         ...this.mimeOptions
                     });
                 }
-
                 if (isFinal) {
                     return this.finalize();
                 }
-
                 return;
             }
         }
-
         this.currentNode.feed(line);
-
         if (isFinal) {
             return this.finalize();
         }
     }
-
+    /** @internal */
     readLine() {
         let startPos = this.readPos;
         let endPos = this.readPos;
-
         while (this.readPos < this.av.length) {
             const c = this.av[this.readPos++];
-
             if (c !== 0x0d && c !== 0x0a) {
                 endPos = this.readPos;
             }
-
             if (c === 0x0a) {
                 return {
                     bytes: new Uint8Array(this.buf, startPos, endPos - startPos),
@@ -4985,302 +5028,202 @@ class PostalMime {
                 };
             }
         }
-
         return {
             bytes: new Uint8Array(this.buf, startPos, endPos - startPos),
             done: this.readPos >= this.av.length
         };
     }
-
-    async processNodeTree() {
-        // get text nodes
-
-        let textContent = {};
-
-        let textTypes = new Set();
-        let textMap = (this.textMap = new Map());
-
-        let forceRfc822Attachments = this.forceRfc822Attachments();
-
-        let walk = async (node, alternative, related) => {
-            alternative = alternative || false;
-            related = related || false;
-
-            if (!node.contentType.multipart) {
-                const inlineRfc822 = this.isInlineMessageRfc822(node) && !forceRfc822Attachments;
-                const rfc822DepthExceeded = inlineRfc822 && this.rfc822NestingDepth >= this.maxRfc822NestingDepth;
-
-                // is it inline message/rfc822
-                if (inlineRfc822 && !rfc822DepthExceeded) {
-                    const subParser = new PostalMime(
-                        {
-                            // Only the limits are inherited. Options that decide how a part
-                            // is classified stay with the parser that was configured.
-                            ...this.mimeOptions,
-                            maxRfc822NestingDepth: this.maxRfc822NestingDepth,
-                            // attachments are encoded by the parent parser, keep raw buffers here
-                            attachmentEncoding: 'arraybuffer'
-                        },
-                        this.rfc822NestingDepth + 1
-                    );
-                    node.subMessage = await subParser.parse(node.content);
-
-                    if (!textMap.has(node)) {
-                        textMap.set(node, {});
-                    }
-
-                    let textEntry = textMap.get(node);
-
-                    // default to text if there is no content
-                    if (node.subMessage.text || !node.subMessage.html) {
-                        textEntry.plain = textEntry.plain || [];
-                        textEntry.plain.push({ type: 'subMessage', value: node.subMessage });
-                        textTypes.add('plain');
-                    }
-
-                    if (node.subMessage.html) {
-                        textEntry.html = textEntry.html || [];
-                        textEntry.html.push({ type: 'subMessage', value: node.subMessage });
-                        textTypes.add('html');
-                    }
-
-                    if (subParser.textMap) {
-                        subParser.textMap.forEach((subTextEntry, subTextNode) => {
-                            textMap.set(subTextNode, subTextEntry);
-                        });
-                    }
-
-                    for (let attachment of node.subMessage.attachments || []) {
-                        this.attachments.push(attachment);
-                    }
-                }
-
-                // is it text?
-                else if (this.isInlineTextNode(node)) {
-                    let textType = node.contentType.parsed.value.substr(node.contentType.parsed.value.indexOf('/') + 1);
-
-                    let selectorNode = alternative || node;
-                    if (!textMap.has(selectorNode)) {
-                        textMap.set(selectorNode, {});
-                    }
-
-                    let textEntry = textMap.get(selectorNode);
-                    textEntry[textType] = textEntry[textType] || [];
-                    textEntry[textType].push({ type: 'text', value: node.getTextContent() });
-                    textTypes.add(textType);
-                }
-
-                // is it an attachment
-                else if (node.content) {
-                    const filename =
-                        node.contentDisposition?.parsed?.params?.filename ||
-                        node.contentType.parsed.params.name ||
-                        null;
-                    const attachment = {
-                        filename: filename ? decodeWords(filename) : null,
-                        mimeType: node.contentType.parsed.value,
-                        disposition: node.contentDisposition?.parsed?.value || null
-                    };
-
-                    // A nested message that was not parsed is not a renderable inline
-                    // resource, so it must not join the cid map behind an <img src>.
-                    if (related && node.contentId && !rfc822DepthExceeded) {
-                        attachment.related = true;
-                    }
-
-                    if (rfc822DepthExceeded) {
-                        // Tell the caller this part would have been parsed inline but hit
-                        // maxRfc822NestingDepth, so anything inside it is not reflected in
-                        // email.text, email.html or email.attachments.
-                        attachment.rfc822DepthExceeded = true;
-                    }
-
-                    if (node.contentDescription) {
-                        // decoded like filename, it is an unstructured header that may
-                        // carry encoded words
-                        attachment.description = decodeWords(node.contentDescription);
-                    }
-
-                    if (node.contentId) {
-                        attachment.contentId = node.contentId;
-                    }
-
-                    switch (node.contentType.parsed.value) {
-                        // Special handling for calendar events
-                        case 'text/calendar':
-                        case 'application/ics': {
-                            if (node.contentType.parsed.params.method) {
-                                attachment.method = node.contentType.parsed.params.method
-                                    .toString()
-                                    .toUpperCase()
-                                    .trim();
-                            }
-
-                            // Enforce into unicode, ending in exactly one newline. The trailing
-                            // newlines are counted rather than replaced with `/\n*$/`, which
-                            // retries at every newline of a run that does not end the text.
-                            const decodedText = node.getTextContent().replace(/\r?\n/g, '\n');
-                            let end = decodedText.length;
-                            while (end > 0 && decodedText.charCodeAt(end - 1) === 0x0a) {
-                                end--;
-                            }
-                            attachment.content = textEncoder.encode(decodedText.slice(0, end) + '\n');
-                            break;
-                        }
-
-                        // Regular attachments
-                        default:
-                            attachment.content = node.content;
-                    }
-
-                    this.attachments.push(attachment);
-                }
-            } else if (node.contentType.multipart === 'alternative') {
-                alternative = node;
-            } else if (node.contentType.multipart === 'related') {
-                related = node;
+    // Records a text part or a nested message under the node that selects it
+    /** @internal */
+    addTextEntry(selector, textType, item) {
+        let textEntry = this.textMap.get(selector);
+        if (!textEntry) {
+            textEntry = {};
+            this.textMap.set(selector, textEntry);
+        }
+        const entries = textEntry[textType] || [];
+        textEntry[textType] = entries;
+        entries.push(item);
+        this.textTypes.add(textType);
+    }
+    // Sorts every leaf of the tree into text content, nested messages and attachments.
+    // `alternative` is the closest enclosing multipart/alternative, if any: its text parts
+    // are collected under the alternative itself, so that the body is assembled from one
+    // representation of it rather than from every one. `related` tells whether the part
+    // sits inside a multipart/related, where a Content-ID makes it an inline resource
+    /** @internal */
+    async collectNode(node, alternative, related) {
+        if (!node.contentType.multipart) {
+            const inlineRfc822 = this.isInlineMessageRfc822(node);
+            const rfc822DepthExceeded = inlineRfc822 && this.rfc822NestingDepth >= this.maxRfc822NestingDepth;
+            if (inlineRfc822 && !rfc822DepthExceeded) {
+                await this.collectSubMessage(node);
             }
-
-            for (let childNode of node.childNodes) {
-                await walk(childNode, alternative, related);
+            else if (this.isInlineTextNode(node)) {
+                const textType = node.contentType.parsed.value === 'text/html' ? 'html' : 'plain';
+                this.addTextEntry(alternative || node, textType, { type: 'text', value: node.getTextContent() });
+            }
+            else if (node.content) {
+                this.collectAttachment(node, node.content, related, rfc822DepthExceeded);
             }
+        }
+        else if (node.contentType.multipart === 'alternative') {
+            alternative = node;
+        }
+        else if (node.contentType.multipart === 'related') {
+            related = true;
+        }
+        for (let childNode of node.childNodes) {
+            await this.collectNode(childNode, alternative, related);
+        }
+    }
+    // Parses an inline message/rfc822 part with a nested parser and takes over its text
+    // parts and attachments
+    /** @internal */
+    async collectSubMessage(node) {
+        const subParser = new PostalMime({
+            // Only the limits are inherited. Options that decide how a part
+            // is classified stay with the parser that was configured.
+            ...this.mimeOptions,
+            maxRfc822NestingDepth: this.maxRfc822NestingDepth,
+            // attachments are encoded by the parent parser, keep raw buffers here
+            attachmentEncoding: 'arraybuffer'
+        });
+        subParser.rfc822NestingDepth = this.rfc822NestingDepth + 1;
+        const subMessage = (node.subMessage = await subParser.parse(node.content || new ArrayBuffer(0)));
+        // default to text if there is no content
+        if (subMessage.text || !subMessage.html) {
+            this.addTextEntry(node, 'plain', { type: 'subMessage', value: subMessage });
+        }
+        if (subMessage.html) {
+            this.addTextEntry(node, 'html', { type: 'subMessage', value: subMessage });
+        }
+        subParser.textMap.forEach((subTextEntry, subTextNode) => {
+            this.textMap.set(subTextNode, subTextEntry);
+        });
+        for (let attachment of subMessage.attachments) {
+            this.attachments.push(attachment);
+        }
+    }
+    /** @internal */
+    collectAttachment(node, content, related, rfc822DepthExceeded) {
+        const filename = node.contentDisposition.parsed.params.filename || node.contentType.parsed.params.name || null;
+        // `content` is filled in below once the part type is known, hence the cast
+        const attachment = {
+            filename: filename ? decodeWords(filename) : null,
+            mimeType: node.contentType.parsed.value,
+            disposition: node.contentDisposition.parsed.value || null
         };
-
-        await walk(this.root, false, false);
-
-        textMap.forEach(mapEntry => {
-            textTypes.forEach(textType => {
-                if (!textContent[textType]) {
-                    textContent[textType] = [];
+        // A nested message that was not parsed is not a renderable inline
+        // resource, so it must not join the cid map behind an <img src>.
+        if (related && node.contentId && !rfc822DepthExceeded) {
+            attachment.related = true;
+        }
+        if (rfc822DepthExceeded) {
+            // Tell the caller this part would have been parsed inline but hit
+            // maxRfc822NestingDepth, so anything inside it is not reflected in
+            // email.text, email.html or email.attachments.
+            attachment.rfc822DepthExceeded = true;
+        }
+        if (node.contentDescription) {
+            // decoded like filename, it is an unstructured header that may
+            // carry encoded words
+            attachment.description = decodeWords(node.contentDescription);
+        }
+        if (node.contentId) {
+            attachment.contentId = node.contentId;
+        }
+        switch (node.contentType.parsed.value) {
+            // Special handling for calendar events
+            case 'text/calendar':
+            case 'application/ics': {
+                if (node.contentType.parsed.params.method) {
+                    attachment.method = node.contentType.parsed.params.method.toString().toUpperCase().trim();
                 }
-
-                if (mapEntry[textType]) {
-                    mapEntry[textType].forEach(textEntry => {
-                        switch (textEntry.type) {
-                            case 'text':
-                                textContent[textType].push(textEntry.value);
-                                break;
-
-                            case 'subMessage':
-                                {
-                                    switch (textType) {
-                                        case 'html':
-                                            textContent[textType].push(formatHtmlHeader(textEntry.value));
-                                            break;
-                                        case 'plain':
-                                            textContent[textType].push(formatTextHeader(textEntry.value));
-                                            break;
-                                    }
-                                }
-                                break;
-                        }
-                    });
-                } else {
-                    let alternativeType;
-                    switch (textType) {
-                        case 'html':
-                            alternativeType = 'plain';
-                            break;
-                        case 'plain':
-                            alternativeType = 'html';
-                            break;
-                    }
-
-                    (mapEntry[alternativeType] || []).forEach(textEntry => {
-                        switch (textEntry.type) {
-                            case 'text':
-                                switch (textType) {
-                                    case 'html':
-                                        textContent[textType].push(textToHtml(textEntry.value));
-                                        break;
-                                    case 'plain':
-                                        textContent[textType].push(htmlToText(textEntry.value));
-                                        break;
-                                }
-                                break;
-
-                            case 'subMessage':
-                                {
-                                    switch (textType) {
-                                        case 'html':
-                                            textContent[textType].push(formatHtmlHeader(textEntry.value));
-                                            break;
-                                        case 'plain':
-                                            textContent[textType].push(formatTextHeader(textEntry.value));
-                                            break;
-                                    }
-                                }
-                                break;
-                        }
-                    });
+                // Enforce into unicode, ending in exactly one newline. The trailing
+                // newlines are counted rather than replaced with `/\n*$/`, which
+                // retries at every newline of a run that does not end the text.
+                const decodedText = node.getTextContent().replace(/\r?\n/g, '\n');
+                let end = decodedText.length;
+                while (end > 0 && decodedText.charCodeAt(end - 1) === 0x0a) {
+                    end--;
+                }
+                attachment.content = textEncoder.encode(decodedText.slice(0, end) + '\n');
+                break;
+            }
+            // Regular attachments
+            default:
+                attachment.content = content;
+        }
+        this.attachments.push(attachment);
+    }
+    // Joins the collected text parts into the plain and html bodies
+    /** @internal */
+    renderTextContent() {
+        const textContent = {};
+        this.textMap.forEach(mapEntry => {
+            this.textTypes.forEach(textType => {
+                const output = textContent[textType] || [];
+                textContent[textType] = output;
+                // a node without a part of this type is rendered from the other type
+                const ownEntries = mapEntry[textType];
+                const entries = ownEntries || mapEntry[textType === 'html' ? 'plain' : 'html'] || [];
+                for (const textEntry of entries) {
+                    output.push(renderEntry(textEntry, textType, !ownEntries));
                 }
             });
         });
-
         Object.keys(textContent).forEach(textType => {
-            textContent[textType] = textContent[textType].join('\n');
+            this.textContent[textType] = textContent[textType].join('\n');
         });
-
-        this.textContent = textContent;
     }
-
+    /** @internal */
     isInlineTextNode(node) {
-        if (node.contentDisposition?.parsed?.value === 'attachment') {
+        if (node.contentDisposition.parsed.value === 'attachment') {
             // no matter the type, this is an attachment
             return false;
         }
-
-        switch (node.contentType.parsed?.value) {
+        switch (node.contentType.parsed.value) {
             case 'text/html':
             case 'text/plain':
                 return true;
-
             case 'text/calendar':
             case 'text/csv':
             default:
                 return false;
         }
     }
-
+    /** @internal */
     isInlineMessageRfc822(node) {
-        if (node.contentType.parsed?.value !== 'message/rfc822') {
+        if (this.forceRfc822Attachments || node.contentType.parsed.value !== 'message/rfc822') {
             return false;
         }
-        let disposition =
-            node.contentDisposition?.parsed?.value || (this.options.rfc822Attachments ? 'attachment' : 'inline');
+        let disposition = node.contentDisposition.parsed.value || (this.options.rfc822Attachments ? 'attachment' : 'inline');
         return disposition === 'inline';
     }
-
-    // Check if this is a specially crafted report email where message/rfc822 content should not be inlined
-    forceRfc822Attachments() {
-        if (this.options.forceRfc822Attachments) {
-            return true;
-        }
-
-        let forceRfc822Attachments = false;
-        let walk = node => {
+    // A delivery status or feedback report carries the offending message as a part. It is
+    // evidence rather than content, so it is not inlined into the body of the report
+    /** @internal */
+    hasReportParts() {
+        let found = false;
+        let walk = (node) => {
             if (!node.contentType.multipart) {
-                if (
-                    node.contentType.parsed &&
-                    ['message/delivery-status', 'message/feedback-report'].includes(node.contentType.parsed.value)
-                ) {
-                    forceRfc822Attachments = true;
+                if (['message/delivery-status', 'message/feedback-report'].includes(node.contentType.parsed.value)) {
+                    found = true;
                 }
             }
-
             for (let childNode of node.childNodes) {
                 walk(childNode);
             }
         };
         walk(this.root);
-        return forceRfc822Attachments;
+        return found;
     }
-
+    /** @internal */
     async resolveStream(stream) {
         let chunkLen = 0;
         let chunks = [];
         const reader = stream.getReader();
-
         while (true) {
             const { done, value } = await reader.read();
             if (done) {
@@ -5289,72 +5232,54 @@ class PostalMime {
             chunks.push(value);
             chunkLen += value.length;
         }
-
         const result = new Uint8Array(chunkLen);
         let chunkPointer = 0;
         for (let chunk of chunks) {
             result.set(chunk, chunkPointer);
             chunkPointer += chunk.length;
         }
-
         return result;
     }
-
-    async parse(buf) {
-        if (this.started) {
-            throw new Error('Can not reuse parser, create a new PostalMime object');
-        }
-        this.started = true;
-
+    /** @internal */
+    async resolveInput(buf) {
+        let input = buf;
         // Check if the input is a readable stream and resolve it into an ArrayBuffer
-        if (buf && typeof buf.getReader === 'function') {
-            buf = await this.resolveStream(buf);
+        if (isReadableStream(input)) {
+            input = await this.resolveStream(input);
         }
-
         // Should it throw for an empty value instead of defaulting to an empty ArrayBuffer?
-        buf = buf || new ArrayBuffer(0);
-
+        input = input || new ArrayBuffer(0);
         // Cast string input to Uint8Array
-        if (typeof buf === 'string') {
-            buf = textEncoder.encode(buf);
+        if (typeof input === 'string') {
+            input = textEncoder.encode(input);
         }
-
         // Cast Blob to ArrayBuffer
-        if (buf instanceof Blob || Object.prototype.toString.call(buf) === '[object Blob]') {
-            buf = await blobToArrayBuffer(buf);
+        if (isBlob(input)) {
+            input = await blobToArrayBuffer(input);
         }
-
         // Cast a Node.js Buffer, a typed array or a DataView into an ArrayBuffer.
         // `new Uint8Array(view)` only works for array-likes, so a DataView produced an
         // empty buffer and the message parsed to nothing without an error. Slicing off
         // byteOffset also keeps views over a larger buffer from reading their neighbours.
-        if (ArrayBuffer.isView(buf)) {
-            buf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-        }
-
-        this.buf = buf;
-
-        this.av = new Uint8Array(buf);
-        this.readPos = 0;
-
-        while (this.readPos < this.av.length) {
-            const line = this.readLine();
-
-            await this.processLine(line.bytes, line.done);
+        if (ArrayBuffer.isView(input)) {
+            return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
         }
-
-        await this.processNodeTree();
-
+        return input;
+    }
+    // Properties are added in the order the output has always had them, so the required
+    // ones are filled in below rather than in the literal
+    /** @internal */
+    buildMessage() {
+        const headers = this.root.headers;
         const message = {
-            headers: this.root.headers.map(entry => ({
+            headers: headers.map(entry => ({
                 key: entry.key,
                 originalKey: entry.originalKey,
                 value: entry.value
             }))
         };
-
         for (const key of ['from', 'sender']) {
-            const addressHeader = this.root.headers.find(line => line.key === key);
+            const addressHeader = headers.find(line => line.key === key);
             if (addressHeader && addressHeader.value) {
                 const addresses = addressParser(addressHeader.value);
                 if (addresses && addresses.length) {
@@ -5362,95 +5287,118 @@ class PostalMime {
                 }
             }
         }
-
-        for (const key of ['delivered-to', 'return-path']) {
-            const addressHeader = this.root.headers.find(line => line.key === key);
+        for (const [key, camelKey] of [
+            ['delivered-to', 'deliveredTo'],
+            ['return-path', 'returnPath']
+        ]) {
+            const addressHeader = headers.find(line => line.key === key);
             if (addressHeader && addressHeader.value) {
                 const addresses = addressParser(addressHeader.value);
                 if (addresses && addresses.length && addresses[0].address) {
-                    const camelKey = toCamelCase(key);
                     message[camelKey] = addresses[0].address;
                 }
             }
         }
-
-        for (const key of ['to', 'cc', 'bcc', 'reply-to']) {
+        for (const [key, camelKey] of [
+            ['to', 'to'],
+            ['cc', 'cc'],
+            ['bcc', 'bcc'],
+            ['reply-to', 'replyTo']
+        ]) {
             // Appended in place, concat() copies the whole list for every header
             const addresses = [];
-            for (const entry of this.root.headers) {
+            for (const entry of headers) {
                 if (entry.key === key && entry.value) {
                     for (const address of addressParser(entry.value)) {
                         addresses.push(address);
                     }
                 }
             }
-
             if (addresses.length) {
-                const camelKey = toCamelCase(key);
                 message[camelKey] = addresses;
             }
         }
-
-        for (const key of ['subject', 'message-id', 'in-reply-to', 'references']) {
-            const header = this.root.headers.find(line => line.key === key);
+        for (const [key, camelKey] of [
+            ['subject', 'subject'],
+            ['message-id', 'messageId'],
+            ['in-reply-to', 'inReplyTo'],
+            ['references', 'references']
+        ]) {
+            const header = headers.find(line => line.key === key);
             if (header && header.value) {
-                const camelKey = toCamelCase(key);
                 message[camelKey] = decodeWords(header.value);
             }
         }
-
-        let dateHeader = this.root.headers.find(line => line.key === 'date');
+        let dateHeader = headers.find(line => line.key === 'date');
         if (dateHeader) {
             let date = new Date(dateHeader.value);
-            if (date.toString() === 'Invalid Date') {
-                date = dateHeader.value;
-            } else {
-                // enforce ISO format if seems to be a valid date
-                date = date.toISOString();
-            }
-            message.date = date;
+            // enforce ISO format if seems to be a valid date
+            message.date = date.toString() === 'Invalid Date' ? dateHeader.value : date.toISOString();
         }
-
-        if (this.textContent?.html) {
+        if (this.textContent.html) {
             message.html = this.textContent.html;
         }
-
-        if (this.textContent?.plain) {
+        if (this.textContent.plain) {
             message.text = this.textContent.plain;
         }
-
         message.attachments = this.attachments;
-
         // Expose raw header lines, in the same order as the headers array
-        message.headerLines = (this.root.rawHeaderLines || []).slice();
-
+        message.headerLines = this.root.rawHeaderLines.slice();
+        return message;
+    }
+    // Every attachment holds binary content at this point, since nested parsers are
+    // created with the arraybuffer encoding. The string check narrows the public content
+    // type rather than handling a reachable case
+    /** @internal */
+    encodeAttachments() {
         switch (this.attachmentEncoding) {
             case 'arraybuffer':
                 break;
-
             case 'base64':
-                for (let attachment of message.attachments || []) {
-                    if (attachment?.content) {
+                for (let attachment of this.attachments) {
+                    if (attachment.content && typeof attachment.content !== 'string') {
                         attachment.content = base64ArrayBuffer(attachment.content);
                         attachment.encoding = 'base64';
                     }
                 }
                 break;
-
-            case 'utf8':
+            case 'utf8': {
                 let attachmentDecoder = new TextDecoder('utf8');
-                for (let attachment of message.attachments || []) {
-                    if (attachment?.content) {
+                for (let attachment of this.attachments) {
+                    if (attachment.content && typeof attachment.content !== 'string') {
                         attachment.content = attachmentDecoder.decode(attachment.content);
                         attachment.encoding = 'utf8';
                     }
                 }
                 break;
-
+            }
             default:
                 throw new Error('Unknown attachment encoding');
         }
-
+    }
+    /**
+     * Parses a raw email message. A parser instance can be used once
+     *
+     * @param buf Raw email message
+     * @returns The parsed email
+     */
+    async parse(buf) {
+        if (this.started) {
+            throw new Error('Can not reuse parser, create a new PostalMime object');
+        }
+        this.started = true;
+        this.buf = await this.resolveInput(buf);
+        this.av = new Uint8Array(this.buf);
+        this.readPos = 0;
+        while (this.readPos < this.av.length) {
+            const line = this.readLine();
+            await this.processLine(line.bytes, line.done);
+        }
+        this.forceRfc822Attachments = Boolean(this.options.forceRfc822Attachments) || this.hasReportParts();
+        await this.collectNode(this.root, false, false);
+        this.renderTextContent();
+        const message = this.buildMessage();
+        this.encodeAttachments();
         return message;
     }
 }
@@ -5602,10 +5550,7 @@ function getSafeEmailImageSrc(src) {
         return;
     }
     const mimeType = getDataUrlMimeType(trimmedSrc);
-    if (!mimeType) {
-        return;
-    }
-    if (!allowedMimeTypes.has(mimeType)) {
+    if (!mimeType || !allowedMimeTypes.has(mimeType)) {
         return;
     }
     return trimmedSrc;
@@ -5741,7 +5686,9 @@ async function fetchEmailBuffer(url) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to load email from ${url}: ${message}`);
+        throw new Error(`Failed to load email from ${url}: ${message}`, {
+            cause: error,
+        });
     }
 }
 async function parseEmail(url, buffer) {
@@ -5752,7 +5699,9 @@ async function parseEmail(url, buffer) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to parse email from ${url}: ${message}`);
+        throw new Error(`Failed to parse email from ${url}: ${message}`, {
+            cause: error,
+        });
     }
 }
 function getRawHeader(email, name) {
@@ -5762,7 +5711,8 @@ function getRawHeader(email, name) {
 function extractAttachments(email) {
     const attachments = [];
     const cidUrlById = new Map();
-    for (const attachment of email.attachments || []) {
+    const emailAttachments = email.attachments || [];
+    for (const attachment of emailAttachments) {
         const contentId = normalizeContentId(attachment.contentId);
         const hasContentId = Boolean(contentId);
         const isInline = (hasContentId && attachment.disposition !== 'attachment') ||
@@ -5866,7 +5816,7 @@ function byteArrayToBase64(bytes) {
         return btoa(binary);
     }
     // Jest/Node fallback
-    return globalThis.Buffer.from(bytes).toString('base64');
+    return Buffer.from(bytes).toString('base64');
 }
 function resolveDataUrlMimeType(mimeType, bytes, filename) {
     const normalizedMimeType = typeof mimeType === 'string' ? mimeType.trim().toLowerCase() : '';
@@ -5889,10 +5839,7 @@ function resolveDataUrlMimeType(mimeType, bytes, filename) {
     return normalizedMimeType || 'application/octet-stream';
 }
 function isTrustedDeclaredImageMimeType(declaredMimeType, detectedMimeType) {
-    if (!detectedMimeType) {
-        return true;
-    }
-    if (declaredMimeType === detectedMimeType) {
+    if (!detectedMimeType || declaredMimeType === detectedMimeType) {
         return true;
     }
     if (declaredMimeType === 'image/jpg' && detectedMimeType === 'image/jpeg') {
@@ -5937,7 +5884,7 @@ function detectSvgMimeType(bytes) {
     if (bytes.length < 5) {
         return;
     }
-    const utf8Prefix = new TextDecoder('utf8', { fatal: false }).decode(bytes.slice(0, Math.min(bytes.length, 256)));
+    const utf8Prefix = new TextDecoder('utf-8', { fatal: false }).decode(bytes.slice(0, Math.min(bytes.length, 256)));
     const normalizedPrefix = utf8Prefix.trimStart().toLowerCase();
     if (normalizedPrefix.startsWith('<svg') ||
         (normalizedPrefix.startsWith('<?xml') &&
@@ -6029,7 +5976,9 @@ function quoteDisplayNameIfNeeded(name) {
     if (!name.includes(',') && !name.includes('"')) {
         return name;
     }
-    const escaped = name.replaceAll('\\', '\\\\').replaceAll('"', '\\' + '"');
+    const escaped = name
+        .replaceAll('\\', '\\\\')
+        .replaceAll('"', String.raw `\"`);
     return `"${escaped}"`;
 }
 
@@ -6214,10 +6163,11 @@ const FileViewer = class {
             this.fileUrl = this.url;
         };
         this.handleToggleFullscreen = () => {
-            if (this.fullscreen.isSupported()) {
-                this.fullscreen.toggle();
-                this.isFullscreen = !this.isFullscreen;
+            if (!this.fullscreen.isSupported()) {
+                return;
             }
+            this.fullscreen.toggle();
+            this.isFullscreen = !this.isFullscreen;
         };
         this.emitOnAction = (event) => {
             event.stopPropagation();
@@ -6235,10 +6185,11 @@ const FileViewer = class {
         });
     }
     connectedCallback() {
-        if (this.revokeAnimationFrame !== undefined) {
-            cancelAnimationFrame(this.revokeAnimationFrame);
-            this.revokeAnimationFrame = undefined;
+        if (this.revokeAnimationFrame === undefined) {
+            return;
         }
+        cancelAnimationFrame(this.revokeAnimationFrame);
+        this.revokeAnimationFrame = undefined;
     }
     async componentWillLoad() {
         this.fileType = detectExtension(this.filename, this.url);
@@ -6276,10 +6227,11 @@ const FileViewer = class {
         return fileViewerFunction();
     }
     revokePdfBlobUrl() {
-        if (this.pdfBlobUrl) {
-            URL.revokeObjectURL(this.pdfBlobUrl);
-            this.pdfBlobUrl = undefined;
+        if (!this.pdfBlobUrl) {
+            return;
         }
+        URL.revokeObjectURL(this.pdfBlobUrl);
+        this.pdfBlobUrl = undefined;
     }
     sanitizeUrl(url) {
         if (!(url === null || url === void 0 ? void 0 : url.trim())) {
@@ -6295,7 +6247,7 @@ const FileViewer = class {
         }
     }
     getTranslation(key) {
-        return translate.get(key, this.language);
+        return translations.get(key, this.language);
     }
     get HostElement() { return getElement(this); }
     static get watchers() { return {