@mavogel/awscdk-rootmail 0.1.25 → 0.1.26

package/node_modules/mailparser/{lib → dist/esm}/mail-parser.js

@@ -1,21 +1,17 @@
-'use strict';
-
-const mailsplit = require('@zone-eu/mailsplit');
-const libmime = require('libmime');
-const addressparser = require('nodemailer/lib/addressparser');
-const Transform = require('stream').Transform;
-const Splitter = mailsplit.Splitter;
-const ChunkedPassthrough = mailsplit.ChunkedPassthrough;
-const punycode = require('punycode.js');
-const FlowedDecoder = require('@zone-eu/mailsplit/lib/flowed-decoder');
-const StreamHash = require('./stream-hash');
-const iconv = require('iconv-lite');
-const { htmlToText } = require('html-to-text');
-const he = require('he');
-const linkify = require('linkify-it')();
-const tlds = require('tlds');
-const encodingJapanese = require('encoding-japanese');
-
+import mailsplit from '@zone-eu/mailsplit';
+import FlowedDecoder from '@zone-eu/mailsplit/lib/flowed-decoder.js';
+import encodingJapanese from 'encoding-japanese';
+import he from 'he';
+import { htmlToText } from 'html-to-text';
+import iconv from 'iconv-lite';
+import libmime from 'libmime';
+import linkifyIt from 'linkify-it';
+import addressparser from 'nodemailer/lib/addressparser';
+import punycode from 'punycode.js';
+import { Transform } from 'node:stream';
+import tlds from './tlds.cjs';
+import StreamHash from './stream-hash.js';
+const { Splitter, ChunkedPassthrough } = mailsplit;
 // Bounds for link detection in text bodies. Message content is untrusted and
 // linkify-it backtracks heavily on crafted input: matching a host is quadratic
 // in the length of a single whitespace-free run and exponential in the number
@@ -33,37 +29,32 @@ const encodingJapanese = require('encoding-japanese');
 const MAX_LINKIFY_SEGMENT_LENGTH = 4096;
 const MAX_LINKIFY_HOST_LABELS = 6;
 const MAX_LINKIFY_WORK = 768 * 1024 * 1024; // shared by all text parts of a message
-
 // Default upper bound for the total length of the URLs updateImageLinks() writes
 // into the HTML (options.maxInlinedImagesSize). simpleParser inlines every cid:
 // reference as a full data: URL, so a small message repeating a reference to
 // one image thousands of times would otherwise grow the HTML past the maximum
 // string length. References beyond the budget are left as cid: links.
 const MAX_INLINED_IMAGES_SIZE = 20 * 1024 * 1024;
-
 // List-* header names that must not become keys of the plain list object
 const UNSAFE_LIST_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-
+const linkify = linkifyIt();
 linkify
     .tlds(tlds) // Reload with full tlds list
     .tlds('onion', true) // Add unofficial `.onion` domain
     .add('git:', 'http:') // Add `git:` ptotocol as "alias"
     .add('ftp:', null) // Disable `ftp:` ptotocol
     .set({ fuzzyIP: true, fuzzyLink: true, fuzzyEmail: true });
-
 // Characters linkify-it accepts inside a host name: letters, digits, a dash,
 // and anything non-ASCII (its label pattern takes any character that is not
 // punctuation, whitespace or a control character).
 function isHostChar(code) {
     return (code >= 0x61 && code <= 0x7a) || (code >= 0x41 && code <= 0x5a) || (code >= 0x30 && code <= 0x39) || code === 0x2d || code >= 0x80;
 }
-
 // twitter linkifier from
 // https://github.com/markdown-it/linkify-it#example-2-add-twitter-mentions-handler
 linkify.add('@', {
     validate(text, pos, self) {
         let tail = text.slice(pos);
-
         if (!self.re.twitter) {
             self.re.twitter = new RegExp('^([a-zA-Z0-9_]){1,15}(?!_)(?=$|' + self.re.src_ZPCc + ')');
         }
@@ -81,7 +72,6 @@ linkify.add('@', {
         match.url = 'https://twitter.com/' + match.url.replace(/^@/, '');
     }
 });
-
 // Lists the parameters a header value gives in RFC 2231 form (name*=, name*0= or
 // name*0*=). libmime decodes those while parsing the header, so the result must not go
 // through decodeWords as well: filename*=utf-8''a%3D%3Futf-8%3FQ%3F%3D2Eexe%3F%3D would
@@ -91,8 +81,7 @@ function rfc2231ParamNames(value) {
     let quote = false;
     let escaped = false;
     let start = 0;
-
-    let addSegment = end => {
+    let addSegment = (end) => {
         let segment = value.substring(start, end);
         let eq = segment.indexOf('=');
         if (eq < 0) {
@@ -107,46 +96,40 @@ function rfc2231ParamNames(value) {
             names.add(match[1]);
         }
     };
-
     for (let i = 0; i < value.length; i++) {
         let chr = value.charAt(i);
         if (escaped) {
             escaped = false;
-        } else if (chr === '\\') {
+        }
+        else if (chr === '\\') {
             escaped = true;
-        } else if (chr === '"') {
+        }
+        else if (chr === '"') {
             quote = !quote;
-        } else if (chr === ';' && !quote) {
+        }
+        else if (chr === ';' && !quote) {
             addSegment(i);
             start = i + 1;
         }
     }
     addSegment(value.length);
-
     return names;
 }
-
 // Deepest element nesting html-to-text is asked to convert. htmlparser2 keeps its open
 // element stack at the front of an array, so parsing alone is quadratic in the nesting
 // depth (200k nested <b> took 9 s), and html-to-text's recursive walk overflows the call
 // stack at about 2000 levels. Real markup stays far below this: Chrome's own parser
 // flattens anything nested deeper than 512 levels.
 const MAX_HTML_NESTING_DEPTH = 1000;
-
 // Elements that never hold content, so a start tag does not open a level
 const HTML_VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
-
 // Elements the HTML parser closes implicitly when a sibling opens (li after li, td after
 // td, p after p), so an unclosed run of them does not nest. They are left out of the depth
 // count: a report with thousands of unclosed table cells is sloppy but common markup
 const HTML_IMPLIED_END_ELEMENTS = new Set(['p', 'li', 'dt', 'dd', 'option', 'optgroup', 'tr', 'td', 'th', 'thead', 'tbody', 'tfoot', 'rt', 'rp']);
-
 function isTagNameChar(code) {
-    return (
-        (code >= 0x61 && code <= 0x7a) || (code >= 0x41 && code <= 0x5a) || (code >= 0x30 && code <= 0x39) || code === 0x2d || code === 0x3a || code === 0x5f
-    );
+    return ((code >= 0x61 && code <= 0x7a) || (code >= 0x41 && code <= 0x5a) || (code >= 0x30 && code <= 0x39) || code === 0x2d || code === 0x3a || code === 0x5f);
 }
-
 // Reports whether `html` nests elements deeper than `maxDepth`, in one linear pass that
 // follows what htmlparser2 builds: a start tag opens an element (a trailing "/" does not
 // close it in HTML mode), an end tag closes down to the nearest open element of that name
@@ -188,7 +171,8 @@ function exceedsHtmlNestingDepth(html, maxDepth) {
                 if (stack.length > maxDepth) {
                     return true;
                 }
-            } else if (open.get(name)) {
+            }
+            else if (open.get(name)) {
                 let popped;
                 do {
                     popped = stack.pop();
@@ -200,21 +184,17 @@ function exceedsHtmlNestingDepth(html, maxDepth) {
     }
     return false;
 }
-
 class IconvDecoder extends Transform {
     constructor(Iconv, charset) {
         super();
-
         // Iconv throws error on ks_c_5601-1987 when it is mapped to EUC-KR
         // https://github.com/bnoordhuis/node-iconv/issues/169
         if (charset.toLowerCase() === 'ks_c_5601-1987') {
             charset = 'CP949';
         }
         this.stream = new Iconv(charset, 'UTF-8//TRANSLIT//IGNORE');
-
         this.inputEnded = false;
         this.endCb = false;
-
         this.stream.on('error', err => this.emit('error', err));
         this.stream.on('data', chunk => this.push(chunk));
         this.stream.on('end', () => {
@@ -224,37 +204,30 @@ class IconvDecoder extends Transform {
             }
         });
     }
-
     _transform(chunk, encoding, done) {
         this.stream.write(chunk);
         done();
     }
-
     _flush(done) {
         this.endCb = done;
         this.stream.end();
     }
 }
-
 class JPDecoder extends Transform {
     constructor(charset) {
         super();
-
         this.charset = charset;
         this.chunks = [];
         this.chunklen = 0;
     }
-
     _transform(chunk, encoding, done) {
         if (typeof chunk === 'string') {
             chunk = Buffer.from(chunk, encoding);
         }
-
         this.chunks.push(chunk);
         this.chunklen += chunk.length;
         done();
     }
-
     _flush(done) {
         let input = Buffer.concat(this.chunks, this.chunklen);
         try {
@@ -267,75 +240,73 @@ class JPDecoder extends Transform {
                 output = Buffer.from(output);
             }
             this.push(output);
-        } catch (err) {
+        }
+        catch {
             // keep as is on errors
             this.push(input);
         }
-
         done();
     }
 }
-
+/**
+ * A lower level, streaming e-mail parser. It is a Transform stream: write the raw message in and
+ * read the parsed content out. It emits:
+ *
+ * - a `headers` event with the parsed headers of the message (see {@link Headers}),
+ * - a `headerLines` event with the raw header lines,
+ * - an {@link AttachmentStream} object for every attachment, whose content stream has to be read
+ *   and `release()` called before the parser continues,
+ * - one {@link MessageText} object with the text content at the end.
+ *
+ * For one-shot parsing into a single object, use `simpleParser` instead.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- the interface below only narrows inherited stream methods
 class MailParser extends Transform {
     constructor(config) {
         super({
             readableObjectMode: true,
             writableObjectMode: false
         });
-
         this.options = config || {};
+        // mailsplit declares its streams with only a 'data' event, the parser uses the other Transform events too
         this.chunkedPassthrough = new ChunkedPassthrough();
         this.splitter = new Splitter(config);
-
         this.chunkedPassthrough.pipe(this.splitter);
-
         this.finished = false;
         this.waitingEnd = false;
-
         this.headers = false;
         this.headerLines = false;
-
         this.endReceived = false;
         this.reading = false;
         this.hasFailed = false;
-
         this.tree = false;
         this.curnode = false;
         this.waitUntilAttachmentEnd = false;
         this.attachmentCallback = false;
-
         this.hasHtml = false;
         this.hasText = false;
-
         this.text = false;
         this.html = false;
         this.textAsHtml = false;
         this.linkifyWork = 0;
-
         this.attachmentList = [];
-
         this.textTypes = ['text/plain', 'text/html'].concat(!this.options.keepDeliveryStatus ? 'message/delivery-status' : []);
-
         this.decoder = this.getDecoder();
-
         this.chunkedPassthrough.on('error', err => {
             this.splitter.emit('error', err);
         });
-
         this.splitter.on('readable', () => {
             if (this.reading) {
                 return false;
             }
             this.readData();
         });
-
         this.splitter.on('end', () => {
             this.endReceived = true;
             if (!this.reading) {
                 this.endStream();
             }
         });
-
         this.splitter.on('error', err => {
             this.hasFailed = true;
             if (typeof this.waitingEnd === 'function') {
@@ -343,10 +314,9 @@ class MailParser extends Transform {
             }
             this.emit('error', err);
         });
-
         this.libmime = new libmime.Libmime({ Iconv: this.options.Iconv });
     }
-
+    /** @internal */
     getDecoder() {
         if (this.options.Iconv) {
             const Iconv = this.options.Iconv;
@@ -358,7 +328,8 @@ class MailParser extends Transform {
                     return new IconvDecoder(Iconv, charset);
                 }
             };
-        } else {
+        }
+        else {
             return {
                 decodeStream(charset) {
                     // resolve charset aliases (eg. iso-8859-8-i -> ISO-8859-8) via libmime's canonical table
@@ -367,13 +338,12 @@ class MailParser extends Transform {
                         // special case not supported by iconv-lite
                         return new JPDecoder(charset);
                     }
-
                     return iconv.decodeStream(charset);
                 }
             };
         }
     }
-
+    /** @internal */
     readData() {
         if (this.hasFailed) {
             return false;
@@ -387,7 +357,6 @@ class MailParser extends Transform {
             }
             return;
         }
-
         this.processChunk(data, err => {
             if (err) {
                 if (typeof this.waitingEnd === 'function') {
@@ -398,10 +367,9 @@ class MailParser extends Transform {
             setImmediate(() => this.readData());
         });
     }
-
+    /** @internal */
     endStream() {
         this.finished = true;
-
         if (this.curnode && this.curnode.decoder) {
             this.curnode.decoder.end();
         }
@@ -409,21 +377,20 @@ class MailParser extends Transform {
             this.waitingEnd();
         }
     }
-
     _transform(chunk, encoding, done) {
         if (!chunk || !chunk.length) {
             return done();
         }
-
         if (this.chunkedPassthrough.write(chunk) === false) {
-            return this.chunkedPassthrough.once('drain', () => {
+            this.chunkedPassthrough.once('drain', () => {
                 done();
             });
-        } else {
+            return;
+        }
+        else {
             return done();
         }
     }
-
     _flush(done) {
         setImmediate(() => this.chunkedPassthrough.end());
         if (this.finished) {
@@ -438,32 +405,32 @@ class MailParser extends Transform {
             this.cleanup(done);
         };
     }
-
+    /** @internal */
     cleanup(done) {
         let finish = () => {
             try {
                 let t = this.getTextContent();
                 this.push(t);
-            } catch (err) {
+            }
+            catch (err) {
                 // report through the stream instead of leaving _flush hanging
                 return done(err);
             }
-
             done();
         };
-
         if (this.curnode && this.curnode.decoder && this.curnode.decoder.readable && !this.decoderEnded) {
             (this.curnode.contentStream || this.curnode.decoder).once('end', () => {
                 finish();
             });
             this.curnode.decoder.end();
-        } else {
+        }
+        else {
             setImmediate(() => {
                 finish();
             });
         }
     }
-
+    /** @internal */
     processHeaders(lines) {
         let headers = new Map();
         (lines || []).forEach(line => {
@@ -486,7 +453,8 @@ class MailParser extends Transform {
                         }
                         try {
                             value.params[key] = this.libmime.decodeWords(value.params[key]);
-                        } catch (E) {
+                        }
+                        catch {
                             // ignore, keep as is
                         }
                     });
@@ -494,7 +462,7 @@ class MailParser extends Transform {
                 }
                 case 'date': {
                     let dateValue = new Date(value);
-                    if (isNaN(dateValue)) {
+                    if (isNaN(dateValue.getTime())) {
                         // date parsing failed :S
                         dateValue = new Date();
                     }
@@ -504,26 +472,29 @@ class MailParser extends Transform {
                 case 'subject':
                     try {
                         value = this.libmime.decodeWords(value);
-                    } catch (E) {
+                    }
+                    catch {
                         // ignore, keep as is
                     }
                     break;
                 case 'references':
                     try {
                         value = this.libmime.decodeWords(value);
-                    } catch (E) {
+                    }
+                    catch {
                         // ignore
                     }
                     value = value
                         .split(/\s+/)
                         .map(this.ensureMessageIDFormat)
-                        .filter(val => val);
+                        .filter((val) => val);
                     break;
                 case 'message-id':
                 case 'in-reply-to':
                     try {
                         value = this.libmime.decodeWords(value);
-                    } catch (E) {
+                    }
+                    catch {
                         // ignore
                     }
                     value = this.ensureMessageIDFormat(value);
@@ -553,29 +524,28 @@ class MailParser extends Transform {
                     };
                     break;
             }
-
             // handle list-* keys
-            if (key.substr(0, 5) === 'list-') {
-                value = this.parseListHeader(key.substr(5), value);
+            if (key.slice(0, 5) === 'list-') {
+                value = this.parseListHeader(key.slice(5), value);
                 key = 'list';
             }
-
             if (value) {
                 if (!headers.has(key)) {
                     headers.set(key, [].concat(value || []));
-                } else if (Array.isArray(value)) {
+                }
+                else if (Array.isArray(value)) {
                     // appended in place: rebuilding the list with concat for every repeated
                     // header was quadratic in the number of References lines
                     let list = headers.get(key);
                     for (let entry of value) {
                         list.push(entry);
                     }
-                } else {
+                }
+                else {
                     headers.get(key).push(value);
                 }
             }
         });
-
         // keep only the first value
         let singleKeys = [
             'message-id',
@@ -596,22 +566,21 @@ class MailParser extends Transform {
             'errors-to',
             'disposition-notification-to'
         ];
-
         headers.forEach((value, key) => {
             if (Array.isArray(value)) {
                 if (singleKeys.includes(key) && value.length) {
                     // the first occurrence: the one mailsplit built the MIME structure from,
                     // and the one mail clients display when the header is duplicated
                     headers.set(key, value[0]);
-                } else if (value.length === 1) {
+                }
+                else if (value.length === 1) {
                     headers.set(key, value[0]);
                 }
             }
-
             if (key === 'list') {
                 // normalize List-* headers
                 let listValue = {};
-                [].concat(value || []).forEach(val => {
+                [].concat(value || []).forEach((val) => {
                     Object.keys(val || {}).forEach(listKey => {
                         listValue[listKey] = val[listKey];
                     });
@@ -619,10 +588,9 @@ class MailParser extends Transform {
                 headers.set(key, listValue);
             }
         });
-
         return headers;
     }
-
+    /** @internal */
     parseListHeader(key, value) {
         if (UNSAFE_LIST_KEYS.has(key)) {
             // would replace the prototype of (or shadow) the normalized list object
@@ -632,23 +600,26 @@ class MailParser extends Transform {
         let response = {};
         let data = addresses
             .map(address => {
-                if (/^https?:/i.test(address.name)) {
-                    response.url = address.name;
-                } else if (address.name) {
-                    response.name = address.name;
-                }
-                if (/^mailto:/.test(address.address)) {
-                    response.mail = address.address.substr(7);
-                } else if (address.address && address.address.indexOf('@') < 0) {
-                    response.id = address.address;
-                } else if (address.address) {
-                    response.mail = address.address;
-                }
-                if (Object.keys(response).length) {
-                    return response;
-                }
-                return false;
-            })
+            if (/^https?:/i.test(address.name)) {
+                response.url = address.name;
+            }
+            else if (address.name) {
+                response.name = address.name;
+            }
+            if (/^mailto:/.test(address.address || '')) {
+                response.mail = address.address.slice(7);
+            }
+            else if (address.address && address.address.indexOf('@') < 0) {
+                response.id = address.address;
+            }
+            else if (address.address) {
+                response.mail = address.address;
+            }
+            if (Object.keys(response).length) {
+                return response;
+            }
+            return false;
+        })
             .filter(address => address);
         if (data.length) {
             return {
@@ -657,20 +628,26 @@ class MailParser extends Transform {
         }
         return false;
     }
-
+    /**
+     * Turns a `Priority`, `X-Priority`, `X-MSMail-Priority` or `Importance` header value into
+     * `'high'`, `'normal'` or `'low'`.
+     */
     parsePriority(value) {
         value = value.toLowerCase().trim();
         if (!isNaN(parseInt(value, 10))) {
             // support "X-Priority: 1 (Highest)"
-            value = parseInt(value, 10) || 0;
-            if (value === 3) {
+            let level = parseInt(value, 10) || 0;
+            if (level === 3) {
                 return 'normal';
-            } else if (value > 3) {
+            }
+            else if (level > 3) {
                 return 'low';
-            } else {
+            }
+            else {
                 return 'high';
             }
-        } else {
+        }
+        else {
             switch (value) {
                 case 'non-urgent':
                 case 'low':
@@ -682,28 +659,26 @@ class MailParser extends Transform {
         }
         return 'normal';
     }
-
+    /**
+     * Wraps a Message-ID in angle brackets where they are missing. Returns `false` for an empty value.
+     */
     ensureMessageIDFormat(value) {
         if (!value.length) {
             return false;
         }
-
         if (value.charAt(0) !== '<') {
             value = '<' + value;
         }
-
         if (value.charAt(value.length - 1) !== '>') {
             value += '>';
         }
-
         return value;
     }
-
+    /** @internal */
     decodeAddresses(addresses) {
         for (let i = 0; i < addresses.length; i++) {
             let address = addresses[i];
             address.name = (address.name || '').toString().trim();
-
             // An encoded word decodes into the display name and nothing else, whatever it
             // decodes to. RFC 2047 section 5 keeps encoded words out of the addr-spec, so a
             // name that decodes to "CEO" <ceo@bank.com> is still only a name: parsing it
@@ -711,7 +686,8 @@ class MailParser extends Transform {
             if (address.name) {
                 try {
                     address.name = this.libmime.decodeWords(address.name);
-                } catch (E) {
+                }
+                catch {
                     //ignore, keep as is
                 }
             }
@@ -723,19 +699,22 @@ class MailParser extends Transform {
                     let decodedAddr = this.libmime.decodeWords(address.address);
                     if (/^[^\s@]+@[^\s@]+$/.test(decodedAddr) && !/[=]\?/.test(decodedAddr)) {
                         address.address = decodedAddr;
-                    } else {
+                    }
+                    else {
                         address.address = '';
                     }
-                } catch (E) {
+                }
+                catch {
                     address.address = '';
                 }
             }
-            if (/@xn--/.test(address.address)) {
+            if (address.address && /@xn--/.test(address.address)) {
                 try {
                     address.address =
-                        address.address.substr(0, address.address.lastIndexOf('@') + 1) +
-                        punycode.toUnicode(address.address.substr(address.address.lastIndexOf('@') + 1));
-                } catch (E) {
+                        address.address.slice(0, address.address.lastIndexOf('@') + 1) +
+                            punycode.toUnicode(address.address.slice(address.address.lastIndexOf('@') + 1));
+                }
+                catch {
                     // Not a valid punycode string; keep as is
                 }
             }
@@ -744,17 +723,15 @@ class MailParser extends Transform {
             }
         }
     }
-
+    /** @internal */
     createNode(node) {
         let contentType = node.contentType;
         let disposition = node.disposition;
         let encoding = node.encoding;
         let charset = node.charset;
-
         if (!contentType && node.root) {
             contentType = 'text/plain';
         }
-
         let newNode = {
             node,
             headerLines: node.headers.lines,
@@ -762,46 +739,37 @@ class MailParser extends Transform {
             contentType,
             children: []
         };
-
         if (!/^multipart\//i.test(contentType)) {
             if (disposition && !['attachment', 'inline'].includes(disposition)) {
                 disposition = 'attachment';
             }
-
             if (!disposition && !this.textTypes.includes(contentType)) {
                 newNode.disposition = 'attachment';
-            } else {
+            }
+            else {
                 newNode.disposition = disposition || 'inline';
             }
-
             newNode.isAttachment = !this.textTypes.includes(contentType) || newNode.disposition !== 'inline';
-
             newNode.encoding = ['quoted-printable', 'base64'].includes(encoding) ? encoding : 'binary';
-
             if (charset) {
                 newNode.charset = charset;
             }
-
             let decoder = node.getDecoder();
             decoder.on('end', () => {
                 this.decoderEnded = true;
             });
             newNode.decoder = decoder;
         }
-
         if (node.root) {
             this.headers = newNode.headers;
             this.headerLines = newNode.headerLines;
         }
-
         // find location in tree
-
-        if (!this.tree) {
+        if (!this.tree || !this.curnode) {
             newNode.root = true;
             this.curnode = this.tree = newNode;
             return newNode;
         }
-
         // immediate child of root node
         if (!this.curnode.parent) {
             newNode.parent = this.curnode;
@@ -809,7 +777,6 @@ class MailParser extends Transform {
             this.curnode = newNode;
             return newNode;
         }
-
         // siblings
         if (this.curnode.parent.node === node.parentNode) {
             newNode.parent = this.curnode.parent;
@@ -817,7 +784,6 @@ class MailParser extends Transform {
             this.curnode = newNode;
             return newNode;
         }
-
         // first child
         if (this.curnode.node === node.parentNode) {
             newNode.parent = this.curnode;
@@ -825,7 +791,6 @@ class MailParser extends Transform {
             this.curnode = newNode;
             return newNode;
         }
-
         // move up
         let parentNode = this.curnode;
         while ((parentNode = parentNode.parent)) {
@@ -836,12 +801,11 @@ class MailParser extends Transform {
                 return newNode;
             }
         }
-
         // should never happen, can't detect parent
         this.curnode = newNode;
         return newNode;
     }
-
+    /** @internal */
     getTextContent() {
         let text = [];
         let html = [];
@@ -850,71 +814,66 @@ class MailParser extends Transform {
             if (node.showMeta) {
                 let meta = ['From', 'Subject', 'Date', 'To', 'Cc', 'Bcc']
                     .map(fkey => {
-                        let key = fkey.toLowerCase();
-                        if (!node.headers.has(key)) {
-                            return false;
-                        }
-                        let value = node.headers.get(key);
-                        if (!value) {
-                            return false;
-                        }
-                        return {
-                            key: fkey,
-                            value: Array.isArray(value) ? value[value.length - 1] : value
-                        };
-                    })
+                    let key = fkey.toLowerCase();
+                    if (!node.headers.has(key)) {
+                        return false;
+                    }
+                    let value = node.headers.get(key);
+                    if (!value) {
+                        return false;
+                    }
+                    return {
+                        key: fkey,
+                        value: (Array.isArray(value) ? value[value.length - 1] : value)
+                    };
+                })
                     .filter(entry => entry);
                 if (this.hasHtml) {
-                    html.push(
-                        '<table class="mp_head">' +
-                            meta
-                                .map(entry => {
-                                    let value = entry.value;
-                                    switch (entry.key) {
-                                        case 'From':
-                                        case 'To':
-                                        case 'Cc':
-                                        case 'Bcc':
-                                            value = value.html;
-                                            break;
-                                        case 'Date':
-                                            value = this.options.formatDateString ? this.options.formatDateString(value) : value.toUTCString();
-                                            break;
-                                        case 'Subject':
-                                            value = '<strong>' + he.encode(value) + '</strong>';
-                                            break;
-                                        default:
-                                            value = he.encode(value);
-                                    }
-
-                                    return '<tr><td class="mp_head_key">' + he.encode(entry.key) + ':</td><td class="mp_head_value">' + value + '<td></tr>';
-                                })
-                                .join('\n') +
-                            '<table>'
-                    );
+                    html.push('<table class="mp_head">' +
+                        meta
+                            .map(entry => {
+                            let value = entry.value;
+                            switch (entry.key) {
+                                case 'From':
+                                case 'To':
+                                case 'Cc':
+                                case 'Bcc':
+                                    value = value.html;
+                                    break;
+                                case 'Date':
+                                    value = this.options.formatDateString ? this.options.formatDateString(value) : value.toUTCString();
+                                    break;
+                                case 'Subject':
+                                    value = '<strong>' + he.encode(value) + '</strong>';
+                                    break;
+                                default:
+                                    value = he.encode(value);
+                            }
+                            return '<tr><td class="mp_head_key">' + he.encode(entry.key) + ':</td><td class="mp_head_value">' + value + '<td></tr>';
+                        })
+                            .join('\n') +
+                        '<table>');
                 }
                 if (this.hasText) {
-                    text.push(
-                        '\n' +
-                            meta
-                                .map(entry => {
-                                    let value = entry.value;
-                                    switch (entry.key) {
-                                        case 'From':
-                                        case 'To':
-                                        case 'Cc':
-                                        case 'Bcc':
-                                            value = value.text;
-                                            break;
-                                        case 'Date':
-                                            value = this.options.formatDateString ? this.options.formatDateString(value) : value.toUTCString();
-                                            break;
-                                    }
-                                    return entry.key + ': ' + value;
-                                })
-                                .join('\n') +
-                            '\n'
-                    );
+                    text.push('\n' +
+                        meta
+                            .map(entry => {
+                            let value = entry.value;
+                            switch (entry.key) {
+                                case 'From':
+                                case 'To':
+                                case 'Cc':
+                                case 'Bcc':
+                                    value = value.text;
+                                    break;
+                                case 'Date':
+                                    value = this.options.formatDateString ? this.options.formatDateString(value) : value.toUTCString();
+                                    break;
+                            }
+                            return entry.key + ': ' + value;
+                        })
+                            .join('\n') +
+                        '\n');
                 }
             }
             if (node.textContent) {
@@ -923,16 +882,19 @@ class MailParser extends Transform {
                     if (!alternative && this.hasHtml) {
                         html.push(this.textToHtml(node.textContent));
                     }
-                } else if (node.contentType === 'message/delivery-status' && !this.options.keepDeliveryStatus) {
+                }
+                else if (node.contentType === 'message/delivery-status' && !this.options.keepDeliveryStatus) {
                     text.push(node.textContent);
                     if (!alternative && this.hasHtml) {
                         html.push(this.textToHtml(node.textContent));
                     }
-                } else if (node.contentType === 'text/html') {
+                }
+                else if (node.contentType === 'text/html') {
                     if ((!alternative && this.hasText) || (node.root && !this.hasText)) {
                         if (this.options.skipHtmlToText) {
                             text.push('');
-                        } else {
+                        }
+                        else {
                             // HTML that can not be converted is no reason to lose the message:
                             // the text stays empty, the HTML is kept and the reason travels with
                             // the result as textConversionError. An 'error' event here used to
@@ -941,12 +903,15 @@ class MailParser extends Transform {
                             let err = null;
                             if (node.textContent.length > this.options.maxHtmlLengthToParse) {
                                 err = new Error(`HTML too long for parsing ${node.textContent.length} bytes`);
-                            } else if (exceedsHtmlNestingDepth(node.textContent, MAX_HTML_NESTING_DEPTH)) {
+                            }
+                            else if (exceedsHtmlNestingDepth(node.textContent, MAX_HTML_NESTING_DEPTH)) {
                                 err = new Error(`HTML nested deeper than ${MAX_HTML_NESTING_DEPTH} levels`);
-                            } else {
+                            }
+                            else {
                                 try {
                                     text.push(htmlToText(node.textContent, { limits: { maxDepth: MAX_HTML_NESTING_DEPTH } }));
-                                } catch (cause) {
+                                }
+                                catch (cause) {
                                     err = new Error('Failed to parse HTML', { cause });
                                 }
                             }
@@ -966,9 +931,7 @@ class MailParser extends Transform {
                 });
             }
         };
-
         processNode(false, 0, this.tree);
-
         let response = {
             type: 'text'
         };
@@ -984,7 +947,7 @@ class MailParser extends Transform {
         }
         return response;
     }
-
+    /** @internal */
     processChunk(data, done) {
         let partId = null;
         if (data._parentBoundary) {
@@ -1001,31 +964,26 @@ class MailParser extends Transform {
                         }
                     });
                     this.emit('headers', node.headers);
-
                     if (node.headerLines) {
                         this.emit('headerLines', node.headerLines);
                     }
                 }
-
                 if (data.contentType === 'message/rfc822' && data.messageNode) {
                     break;
                 }
-
                 if (data.parentNode && data.parentNode.contentType === 'message/rfc822') {
                     node.showMeta = true;
                 }
-
                 if (node.isAttachment) {
+                    let decoder = node.decoder;
                     let contentType = node.contentType;
                     if (node.contentType === 'application/octet-stream' && data.filename) {
                         contentType = this.libmime.detectMimeType(data.filename) || 'application/octet-stream';
                     }
-
                     // backpressure state for the attachment stream, see pump() below
                     let released = false;
                     let waitingDrain = false;
-                    let pump = null;
-
+                    let pump;
                     let attachment = {
                         type: 'attachment',
                         content: null,
@@ -1045,59 +1003,53 @@ class MailParser extends Transform {
                             this.waitUntilAttachmentEnd = false;
                         }
                     };
-
                     let algo = this.options.checksumAlgo || 'md5';
                     let hasher;
                     try {
                         hasher = new StreamHash(attachment, algo);
-                    } catch (err) {
+                    }
+                    catch (err) {
                         // an algorithm this Node does not offer (a typo, or MD5 on a host whose
                         // OpenSSL runs in FIPS mode) is a parser error, not a process-ending throw
                         err.message = `Checksum algorithm "${algo}" is not available: ${err.message}`;
                         return done(err);
                     }
-                    node.decoder.on('error', err => {
+                    decoder.on('error', err => {
                         hasher.emit('error', err);
                     });
-
                     // Honour the consumer's backpressure while it reads the attachment. Once the
                     // attachment is released it is drained regardless, so that a caller that
                     // releases without reading the content does not stall the parser.
                     pump = () => {
                         let chunk;
-                        while ((chunk = node.decoder.read()) !== null) {
+                        while ((chunk = decoder.read()) !== null) {
                             if (hasher.write(chunk) === false && !released) {
                                 waitingDrain = true;
-                                return hasher.once('drain', () => {
+                                hasher.once('drain', () => {
                                     waitingDrain = false;
                                     pump();
                                 });
+                                return;
                             }
                         }
                     };
-
-                    node.decoder.on('readable', () => {
+                    decoder.on('readable', () => {
                         if (!waitingDrain) {
                             pump();
                         }
                     });
-
-                    node.decoder.once('end', () => {
+                    decoder.once('end', () => {
                         hasher.end();
                     });
-
                     //node.decoder.pipe(hasher);
                     attachment.content = hasher;
-
                     this.waitUntilAttachmentEnd = true;
                     if (data.disposition) {
                         attachment.contentDisposition = data.disposition;
                     }
-
                     if (data.filename) {
                         attachment.filename = data.filename;
                     }
-
                     if (node.headers.has('content-id')) {
                         attachment.contentId = [].concat(node.headers.get('content-id') || []).shift();
                         attachment.cid = attachment.contentId.trim().replace(/^<|>$/g, '').trim();
@@ -1109,23 +1061,23 @@ class MailParser extends Transform {
                             }
                         }
                     }
-
                     attachment.headers = node.headers;
                     this.push(attachment);
                     this.attachmentList.push(attachment);
-                } else if (node.disposition === 'inline') {
+                }
+                else if (node.disposition === 'inline') {
                     let chunks = [];
                     let chunklen = 0;
                     node.contentStream = node.decoder;
-
                     if (node.contentType === 'text/plain') {
                         this.hasText = true;
-                    } else if (node.contentType === 'text/html') {
+                    }
+                    else if (node.contentType === 'text/html') {
                         this.hasHtml = true;
-                    } else if (node.contentType === 'message/delivery-status' && !this.options.keepDeliveryStatus) {
+                    }
+                    else if (node.contentType === 'message/delivery-status' && !this.options.keepDeliveryStatus) {
                         this.hasText = true;
                     }
-
                     if (node.node.flowed) {
                         let contentStream = node.contentStream;
                         let flowDecoder = new FlowedDecoder({
@@ -1137,10 +1089,8 @@ class MailParser extends Transform {
                         contentStream.pipe(flowDecoder);
                         node.contentStream = flowDecoder;
                     }
-
                     let charset = node.charset || 'utf-8';
                     //charset = charset || 'windows-1257';
-
                     if (!['ascii', 'usascii', 'utf8'].includes(charset.toLowerCase().replace(/[^a-z0-9]+/g, ''))) {
                         try {
                             let contentStream = node.contentStream;
@@ -1150,14 +1100,15 @@ class MailParser extends Transform {
                             });
                             contentStream.pipe(decodeStream);
                             node.contentStream = decodeStream;
-                        } catch (E) {
+                        }
+                        catch {
                             // do not decode charset
                         }
                     }
-
-                    node.contentStream.on('readable', () => {
+                    let contentStream = node.contentStream;
+                    contentStream.on('readable', () => {
                         let chunk;
-                        while ((chunk = node.contentStream.read()) !== null) {
+                        while ((chunk = contentStream.read()) !== null) {
                             if (typeof chunk === 'string') {
                                 chunk = Buffer.from(chunk);
                             }
@@ -1165,114 +1116,113 @@ class MailParser extends Transform {
                             chunklen += chunk.length;
                         }
                     });
-
-                    node.contentStream.once('end', () => {
+                    contentStream.once('end', () => {
                         node.textContent = Buffer.concat(chunks, chunklen).toString().replace(/\r?\n/g, '\n');
                     });
-
-                    node.contentStream.once('error', err => {
+                    contentStream.once('error', err => {
                         this.emit('error', err);
                     });
                 }
-
                 break;
             }
-
             case 'data':
                 if (this.curnode && this.curnode.decoder) {
                     this.curnode.decoder.end();
                 }
-
                 if (this.waitUntilAttachmentEnd) {
                     this.attachmentCallback = done;
                     return;
                 }
-
                 // multipart message structure
                 // this is not related to any specific 'node' block as it includes
                 // everything between the end of some node body and between the next header
                 //process.stdout.write(data.value);
                 break;
-
             case 'body':
                 if (this.curnode && this.curnode.decoder && this.curnode.decoder.writable) {
                     if (this.curnode.decoder.write(data.value) === false) {
-                        return this.curnode.decoder.once('drain', done);
+                        this.curnode.decoder.once('drain', done);
+                        return;
                     }
                 }
-
                 // Leaf element body. Includes the body for the last 'node' block. You might
                 // have several 'body' calls for a single 'node' block
                 //process.stdout.write(data.value);
                 break;
         }
-
         setImmediate(done);
     }
-
+    /**
+     * Formats parsed addresses for an HTML context, every value HTML-escaped.
+     */
     getAddressesHTML(value) {
-        let formatSingleLevel = addresses =>
-            addresses
-                .map(address => {
-                    let str = '<span class="mp_address_group">';
-                    if (address.name) {
-                        str += '<span class="mp_address_name">' + he.encode(address.name) + (address.group ? ': ' : '') + '</span>';
-                    }
-                    if (address.address) {
-                        let link = '<a href="mailto:' + he.encode(address.address) + '" class="mp_address_email">' + he.encode(address.address) + '</a>';
-                        if (address.name) {
-                            str += ' &lt;' + link + '&gt;';
-                        } else {
-                            str += link;
-                        }
-                    }
-                    if (address.group) {
-                        str += formatSingleLevel(address.group) + ';';
-                    }
-                    return str + '</span>';
-                })
-                .join(', ');
+        let formatSingleLevel = (addresses) => addresses
+            .map(address => {
+            let str = '<span class="mp_address_group">';
+            if (address.name) {
+                str += '<span class="mp_address_name">' + he.encode(address.name) + (address.group ? ': ' : '') + '</span>';
+            }
+            if (address.address) {
+                let link = '<a href="mailto:' + he.encode(address.address) + '" class="mp_address_email">' + he.encode(address.address) + '</a>';
+                if (address.name) {
+                    str += ' &lt;' + link + '&gt;';
+                }
+                else {
+                    str += link;
+                }
+            }
+            if (address.group) {
+                str += formatSingleLevel(address.group) + ';';
+            }
+            return str + '</span>';
+        })
+            .join(', ');
         return formatSingleLevel([].concat(value || []));
     }
-
+    /**
+     * Formats parsed addresses as plain text, display names quoted.
+     */
     getAddressesText(value) {
-        let formatSingleLevel = addresses =>
-            addresses
-                .map(address => {
-                    let str = '';
-                    if (address.name) {
-                        // a quoted-string, so a quote or backslash inside the name is escaped
-                        str += `"${address.name.replace(/["\\]/g, '\\$&')}"` + (address.group ? ': ' : '');
-                    }
-                    if (address.address) {
-                        let link = address.address;
-                        if (address.name) {
-                            str += ' <' + link + '>';
-                        } else {
-                            str += link;
-                        }
-                    }
-                    if (address.group) {
-                        str += formatSingleLevel(address.group) + ';';
-                    }
-                    return str;
-                })
-                .join(', ');
+        let formatSingleLevel = (addresses) => addresses
+            .map(address => {
+            let str = '';
+            if (address.name) {
+                // a quoted-string, so a quote or backslash inside the name is escaped
+                str += `"${address.name.replace(/["\\]/g, '\\$&')}"` + (address.group ? ': ' : '');
+            }
+            if (address.address) {
+                let link = address.address;
+                if (address.name) {
+                    str += ' <' + link + '>';
+                }
+                else {
+                    str += link;
+                }
+            }
+            if (address.group) {
+                str += formatSingleLevel(address.group) + ';';
+            }
+            return str;
+        })
+            .join(', ');
         return formatSingleLevel([].concat(value || []));
     }
-
+    /**
+     * Replaces `cid:` links to image attachments in the HTML content. Call it once the parser has
+     * ended. `replaceCallback` is called once for every referenced image attachment and answers with
+     * the URL to use instead; `done` gets the updated HTML, or `false` when the message has no HTML.
+     * The total length of the URLs written is bounded by `maxInlinedImagesSize`.
+     */
     updateImageLinks(replaceCallback, done) {
         if (!this.html) {
-            return setImmediate(() => done(null, false));
+            setImmediate(() => done(null, false));
+            return;
         }
-
         let cids = new Map();
         let html = (this.html || '').toString();
-
         if (this.options.skipImageLinks) {
             return done(null, html);
         }
-
         html.replace(/\bcid:([^'"\s]{1,256})/g, (match, cid) => {
             for (let i = 0, len = this.attachmentList.length; i < len; i++) {
                 if (this.attachmentList[i].cid === cid && /^image\/[\w]+$/i.test(this.attachmentList[i].contentType)) {
@@ -1284,12 +1234,10 @@ class MailParser extends Transform {
             }
             return match;
         });
-
         let cidList = [];
         cids.forEach(entry => {
             cidList.push(entry);
         });
-
         let pos = 0;
         let processNext = () => {
             if (pos >= cidList.length) {
@@ -1311,36 +1259,35 @@ class MailParser extends Transform {
                         inlinedSize += url.length;
                         return url;
                     });
-                } catch (err) {
+                }
+                catch (err) {
                     // runs from setImmediate, a throw here would be an uncaught exception
                     return done(err);
                 }
-
                 return done(null, html);
             }
             let entry = cidList[pos++];
             replaceCallback(entry.attachment, (err, url) => {
                 if (err) {
-                    return setImmediate(() => done(err));
+                    setImmediate(() => done(err));
+                    return;
                 }
                 entry.url = url;
                 setImmediate(processNext);
             });
         };
-
         setImmediate(processNext);
     }
-
     // Tells whether a text segment is worth handing to linkify-it, see
     // MAX_LINKIFY_* above. Note that linkify.pretest() can not be used for this
     // - it is a quick deny that also denies links its own matcher finds, eg. a
     // host followed by a fullwidth vertical bar.
+    /** @internal */
     canScanSegment(segment) {
         // every link linkify-it can find contains at least one of these
         if (segment.length > MAX_LINKIFY_SEGMENT_LENGTH || !/[.:@/]/.test(segment)) {
             return false;
         }
-
         // Dots only chain up into one host candidate while the characters
         // around them could be part of a host, so a slash, comma or colon ends
         // the chain and dots in a path or query do not add to it.
@@ -1351,21 +1298,19 @@ class MailParser extends Transform {
                 if (++labels > MAX_LINKIFY_HOST_LABELS) {
                     return false;
                 }
-            } else if (!isHostChar(code)) {
+            }
+            else if (!isHostChar(code)) {
                 labels = 0;
             }
         }
-
         return true;
     }
-
+    /** @internal */
     findLinks(str) {
         let links = [];
-
         if (this.linkifyWork >= MAX_LINKIFY_WORK || !linkify.pretest(str)) {
             return links;
         }
-
         // Whitespace can not be part of a link and linkify-it treats the end of
         // a segment exactly like whitespace, so scanning segment by segment
         // finds the same links as scanning the entire string would. U+FEFF is
@@ -1373,89 +1318,80 @@ class MailParser extends Transform {
         // linkify-it, so it must not end a segment.
         let segmentRegex = /[\S\uFEFF]+/g;
         let segmentMatch;
-
         while ((segmentMatch = segmentRegex.exec(str)) !== null) {
             let segment = segmentMatch[0];
-
             if (!this.canScanSegment(segment)) {
                 // too expensive to scan or can not match at all, keep as plain text
                 continue;
             }
-
             let matches = linkify.match(segment);
             for (let i = 0; matches && i < matches.length; i++) {
                 matches[i].index += segmentMatch.index;
                 matches[i].lastIndex += segmentMatch.index;
                 links.push(matches[i]);
             }
-
             this.linkifyWork += segment.length * (segment.length + 1024);
             if (this.linkifyWork >= MAX_LINKIFY_WORK) {
                 break;
             }
         }
-
         return links;
     }
-
+    /**
+     * Converts plain text to HTML the way `textAsHtml` is built: HTML-escaped, paragraphs and line
+     * breaks kept, and links turned into anchors unless `skipTextLinks` is set. Returns an empty
+     * string when `skipTextToHtml` is set.
+     */
     textToHtml(str) {
         if (this.options.skipTextToHtml) {
             return '';
         }
         str = (str || '').toString();
         let encoded;
-
         if (!this.options.skipTextLinks) {
             try {
                 let links = this.findLinks(str);
                 if (links.length) {
                     let result = [];
                     let last = 0;
-
                     links.forEach(link => {
                         if (last < link.index) {
                             let textPart = he
                                 // encode special chars
                                 .encode(str.slice(last, link.index), {
-                                    useNamedReferences: true
-                                });
+                                useNamedReferences: true
+                            });
                             result.push(textPart);
                         }
-
                         // Escape quotes in URL to prevent XSS
                         let safeUrl = link.url.replace(/"/g, '&quot;');
                         // Escape HTML entities in link text
                         let safeText = he.encode(link.text, { useNamedReferences: true });
                         result.push(`<a href="${safeUrl}">${safeText}</a>`);
-
                         last = link.lastIndex;
                     });
-
                     let textPart = he
                         // encode special chars
                         .encode(str.slice(last), {
-                            useNamedReferences: true
-                        });
+                        useNamedReferences: true
+                    });
                     result.push(textPart);
-
                     encoded = result.join('');
                 }
-            } catch (E) {
+            }
+            catch {
                 // failed, don't linkify
             }
         }
-
         // nothing linkified, or linkifying threw halfway through
         if (!encoded) {
             encoded = he
                 // encode special chars
                 .encode(str, {
-                    useNamedReferences: true
-                });
+                useNamedReferences: true
+            });
         }
-
-        let text =
-            '<p>' +
+        let text = '<p>' +
             encoded
                 .replace(/\r?\n/g, '\n')
                 .trim() // normalize line endings
@@ -1470,9 +1406,7 @@ class MailParser extends Transform {
                 .trim() // insert <p> to multiple linebreaks
                 .replace(/\n/g, '<br/>') + // insert <br> to single linebreaks
             '</p>';
-
         return text;
     }
 }
-
-module.exports = MailParser;
+export default MailParser;