@mavogel/awscdk-rootmail 0.1.26 → 0.1.28

package/node_modules/mailparser/dist/cjs/mail-parser.js

@@ -5,17 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const mailsplit_1 = __importDefault(require("@zone-eu/mailsplit"));
 const flowed_decoder_js_1 = __importDefault(require("@zone-eu/mailsplit/lib/flowed-decoder.js"));
-const encoding_japanese_1 = __importDefault(require("encoding-japanese"));
 const he_1 = __importDefault(require("he"));
 const html_to_text_1 = require("html-to-text");
-const iconv_lite_1 = __importDefault(require("iconv-lite"));
 const libmime_1 = __importDefault(require("libmime"));
 const linkify_it_1 = __importDefault(require("linkify-it"));
 const addressparser_1 = __importDefault(require("nodemailer/lib/addressparser"));
-const punycode_js_1 = __importDefault(require("punycode.js"));
 const node_stream_1 = require("node:stream");
 const tlds_cjs_1 = __importDefault(require("./tlds.cjs"));
 const stream_hash_js_1 = __importDefault(require("./stream-hash.js"));
+const address_header_js_1 = require("./address-header.js");
 const { Splitter, ChunkedPassthrough } = mailsplit_1.default;
 // Bounds for link detection in text bodies. Message content is untrusted and
 // linkify-it backtracks heavily on crafted input: matching a host is quadratic
@@ -77,49 +75,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
-// otherwise come out as "a.exe" while a parser that decodes once sees the encoded word.
-function rfc2231ParamNames(value) {
-    let names = new Set();
-    let quote = false;
-    let escaped = false;
-    let start = 0;
-    let addSegment = (end) => {
-        let segment = value.substring(start, end);
-        let eq = segment.indexOf('=');
-        if (eq < 0) {
-            return;
-        }
-        let match = segment
-            .substring(0, eq)
-            .trim()
-            .toLowerCase()
-            .match(/^(.+?)\*(\d+\*?)?$/);
-        if (match) {
-            names.add(match[1]);
-        }
-    };
-    for (let i = 0; i < value.length; i++) {
-        let chr = value.charAt(i);
-        if (escaped) {
-            escaped = false;
-        }
-        else if (chr === '\\') {
-            escaped = true;
-        }
-        else if (chr === '"') {
-            quote = !quote;
-        }
-        else if (chr === ';' && !quote) {
-            addSegment(i);
-            start = i + 1;
-        }
-    }
-    addSegment(value.length);
-    return names;
-}
 // Deepest element nesting html-to-text is asked to convert. htmlparser2 keeps its open
 // element stack at the front of an array, so parsing alone is quadratic in the nesting
 // depth (200k nested <b> took 9 s), and html-to-text's recursive walk overflows the call
@@ -189,6 +144,14 @@ function exceedsHtmlNestingDepth(html, maxDepth) {
     }
     return false;
 }
+// Charsets a body is never decoded from, matched the way iconv-lite and node-iconv compare names
+// (case and punctuation ignored). UTF-7 can carry markup past a filter that looks for "<" (a body
+// of +ADw-script+AD4- decodes to <script>), base64 and hex are transfer encodings. libmime's decode
+// stream refuses the same names, this check applies the refusal to the native Iconv option as well
+const REFUSED_CHARSET = /^(?:(?:cs)?unicode11)?utf7(?:imap)?$|^base64$|^hex$/;
+function isRefusedCharset(charset) {
+    return REFUSED_CHARSET.test((charset || '').toLowerCase().replace(/[^a-z0-9]/g, ''));
+}
 class IconvDecoder extends node_stream_1.Transform {
     constructor(Iconv, charset) {
         super();
@@ -218,41 +181,6 @@ class IconvDecoder extends node_stream_1.Transform {
         this.stream.end();
     }
 }
-class JPDecoder extends node_stream_1.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 {
-            let output = encoding_japanese_1.default.convert(input, {
-                to: 'UNICODE', // to_encoding
-                from: this.charset, // from_encoding
-                type: 'string'
-            });
-            if (typeof output === 'string') {
-                output = Buffer.from(output);
-            }
-            this.push(output);
-        }
-        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:
@@ -328,6 +256,10 @@ class MailParser extends node_stream_1.Transform {
             // create wrapper
             return {
                 decodeStream(charset) {
+                    if (isRefusedCharset(charset)) {
+                        // the same refusal as without the Iconv option, see below
+                        return libmime_1.default.createDecodeStream(charset);
+                    }
                     // node-iconv resolves its own charset aliases and needs charset-specific
                     // fixups (see IconvDecoder, eg. ks_c_5601-1987), so pass the charset through as is
                     return new IconvDecoder(Iconv, charset);
@@ -337,13 +269,12 @@ class MailParser extends node_stream_1.Transform {
         else {
             return {
                 decodeStream(charset) {
-                    // resolve charset aliases (eg. iso-8859-8-i -> ISO-8859-8) via libmime's canonical table
-                    charset = libmime_1.default.normalizeCharset((charset || 'ascii').toString());
-                    if (/^jis|^iso-?2022-?jp/i.test(charset)) {
-                        // special case not supported by iconv-lite
-                        return new JPDecoder(charset);
-                    }
-                    return iconv_lite_1.default.decodeStream(charset);
+                    // libmime resolves charset aliases (eg. iso-8859-8-i -> ISO-8859-8), decodes the
+                    // Japanese charsets iconv-lite lacks and keeps a multibyte character split across
+                    // chunks intact. A charset it does not know or refuses (UTF-7, which would turn
+                    // +ADw-script+AD4- into <script>, and the base64 and hex transfer encodings) is
+                    // decoded as UTF-8 with invalid bytes replaced, the same as encoded words get
+                    return libmime_1.default.createDecodeStream(charset || 'ascii');
                 }
             };
         }
@@ -446,9 +377,18 @@ class MailParser extends node_stream_1.Transform {
                 case 'content-type':
                 case 'content-disposition':
                 case 'dkim-signature': {
-                    // a parameter given in RFC 2231 form is decoded by parseHeaderValue already
-                    let rfc2231 = rfc2231ParamNames(value);
-                    value = this.libmime.parseHeaderValue(value);
+                    // The comments of a MIME header are not part of its value, so they are
+                    // dropped as mailsplit drops them for the structure: `boundary=b (comment)`
+                    // names the boundary `b`. A DKIM-Signature is a tag list without comment
+                    // syntax, so a parenthesis in a tag value is data
+                    value = this.libmime.parseHeaderValue(value, { stripComments: key !== 'dkim-signature' });
+                    // A parameter given in RFC 2231 form was decoded by parseHeaderValue already,
+                    // which names it in decodedParams, and must not go through decodeWords as
+                    // well: filename*=utf-8''a%3D%3Futf-8%3FQ%3F%3D2Eexe%3F%3D would otherwise come
+                    // out as a.exe while a parser that decodes once sees the encoded word. A
+                    // second scan of the raw header for the name used to decide this, and read
+                    // `(c)filename*=` as `(c)filename` once the comment was dropped from the real one
+                    let rfc2231 = new Set(value.decodedParams);
                     if (value.value) {
                         value.value = this.libmime.decodeWords(value.value);
                     }
@@ -681,52 +621,7 @@ class MailParser extends node_stream_1.Transform {
     }
     /** @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
-            // again would report an address the header never carried
-            if (address.name) {
-                try {
-                    address.name = this.libmime.decodeWords(address.name);
-                }
-                catch {
-                    //ignore, keep as is
-                }
-            }
-            // Security fix: detect RFC 2047 encoded-words in the address field.
-            // Per RFC 2047 Section 5, encoded-words MUST NOT appear in addr-spec.
-            // If found, decode and validate; reject if result is not a simple local@domain.
-            if (address.address && /[=]\?[^?]+\?[BbQq]\?[^?]*\?[=]/.test(address.address)) {
-                try {
-                    let decodedAddr = this.libmime.decodeWords(address.address);
-                    if (/^[^\s@]+@[^\s@]+$/.test(decodedAddr) && !/[=]\?/.test(decodedAddr)) {
-                        address.address = decodedAddr;
-                    }
-                    else {
-                        address.address = '';
-                    }
-                }
-                catch {
-                    address.address = '';
-                }
-            }
-            if (address.address && /@xn--/.test(address.address)) {
-                try {
-                    address.address =
-                        address.address.slice(0, address.address.lastIndexOf('@') + 1) +
-                            punycode_js_1.default.toUnicode(address.address.slice(address.address.lastIndexOf('@') + 1));
-                }
-                catch {
-                    // Not a valid punycode string; keep as is
-                }
-            }
-            if (address.group) {
-                this.decodeAddresses(address.group);
-            }
-        }
+        (0, address_header_js_1.decodeAddresses)(addresses, this.libmime);
     }
     /** @internal */
     createNode(node) {
@@ -1008,7 +903,8 @@ class MailParser extends node_stream_1.Transform {
                             this.waitUntilAttachmentEnd = false;
                         }
                     };
-                    let algo = this.options.checksumAlgo || 'md5';
+                    // false skips hashing, checksum is then left unset
+                    let algo = this.options.checksumAlgo === false ? false : this.options.checksumAlgo || 'md5';
                     let hasher;
                     try {
                         hasher = new stream_hash_js_1.default(attachment, algo);
@@ -1161,56 +1057,13 @@ class MailParser extends node_stream_1.Transform {
      * 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_1.default.encode(address.name) + (address.group ? ': ' : '') + '</span>';
-            }
-            if (address.address) {
-                let link = '<a href="mailto:' + he_1.default.encode(address.address) + '" class="mp_address_email">' + he_1.default.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 || []));
+        return (0, address_header_js_1.formatAddressesHTML)(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(', ');
-        return formatSingleLevel([].concat(value || []));
+        return (0, address_header_js_1.formatAddressesText)(value);
     }
     /**
      * Replaces `cid:` links to image attachments in the HTML content. Call it once the parser has

package/node_modules/mailparser/dist/cjs/stream-hash.d.ts

@@ -10,14 +10,15 @@ export interface HashTarget {
 }
 /**
  * A pass-through stream that records the checksum and byte size of what flows through it on the
- * given object once the stream ends. Throws when the hash algorithm is not available.
+ * given object once the stream ends. Throws when the hash algorithm is not available. With `algo`
+ * set to `false` nothing is hashed and only the size is recorded.
  */
 declare class StreamHash extends Transform {
     attachment: HashTarget;
-    algo: string;
-    hash: crypto.Hash;
+    algo: string | false;
+    hash: crypto.Hash | null;
     byteCount: number;
-    constructor(attachment: HashTarget, algo?: string);
+    constructor(attachment: HashTarget, algo?: string | false);
     _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
     _flush(done: TransformCallback): void;
 }

package/node_modules/mailparser/dist/cjs/stream-hash.js

@@ -7,23 +7,26 @@ const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_stream_1 = require("node:stream");
 /**
  * A pass-through stream that records the checksum and byte size of what flows through it on the
- * given object once the stream ends. Throws when the hash algorithm is not available.
+ * given object once the stream ends. Throws when the hash algorithm is not available. With `algo`
+ * set to `false` nothing is hashed and only the size is recorded.
  */
 class StreamHash extends node_stream_1.Transform {
     constructor(attachment, algo) {
         super();
         this.attachment = attachment;
-        this.algo = (algo || 'md5').toLowerCase();
-        this.hash = node_crypto_1.default.createHash(this.algo);
+        this.algo = algo === false ? false : (algo || 'md5').toLowerCase();
+        this.hash = this.algo === false ? null : node_crypto_1.default.createHash(this.algo);
         this.byteCount = 0;
     }
     _transform(chunk, encoding, done) {
-        this.hash.update(chunk);
+        this.hash?.update(chunk);
         this.byteCount += chunk.length;
         done(null, chunk);
     }
     _flush(done) {
-        this.attachment.checksum = this.hash.digest('hex');
+        if (this.hash) {
+            this.attachment.checksum = this.hash.digest('hex');
+        }
         this.attachment.size = this.byteCount;
         done();
     }

package/node_modules/mailparser/dist/cjs/types.d.ts

@@ -37,6 +37,24 @@ export interface AddressObject {
     /** The addresses formatted as plain text, display names quoted. */
     text: string;
 }
+/**
+ * Options for `parseAddressHeader`.
+ */
+export interface ParseAddressHeaderOptions {
+    /**
+     * Replace every group with its members, so the result lists mailboxes only and the group names
+     * are dropped.
+     * @default false
+     */
+    flatten?: boolean;
+    /**
+     * Decode an internationalized (punycode) domain to Unicode. Set to false to keep the domain as
+     * it appears in the header, for an address that is going to be used to send mail, such as an
+     * SMTP envelope, where the ASCII form is the one every server accepts.
+     * @default true
+     */
+    decodePunycode?: boolean;
+}
 /**
  * One entry of the combined `list` header, built from a `List-*` header such as `List-Unsubscribe`.
  */
@@ -122,7 +140,10 @@ export interface AttachmentStream extends AttachmentCommon {
      * message. Must be called for every attachment. Set to `null` once called.
      */
     release: (() => void) | null;
-    /** The hex encoded checksum of the content (md5 unless `checksumAlgo` says otherwise). Set once `content` has ended. */
+    /**
+     * The hex encoded checksum of the content (md5 unless `checksumAlgo` says otherwise). Set once
+     * `content` has ended, never when `checksumAlgo` is `false`.
+     */
     checksum?: string;
     /** The size of the decoded content in bytes. Set once `content` has ended. */
     size?: number;
@@ -135,7 +156,11 @@ export interface Attachment extends AttachmentCommon {
     content: Buffer;
     /** Always `null`, `simpleParser` has released the attachment already. */
     release: null;
-    /** The hex encoded checksum of the content (md5 unless `checksumAlgo` says otherwise). */
+    /**
+     * The hex encoded checksum of the content (md5 unless `checksumAlgo` says otherwise). Not set when
+     * `checksumAlgo` is `false`: the type keeps it a string so code written for the default does not
+     * have to check it, so a caller that turns hashing off must not read it.
+     */
     checksum: string;
     /** The size of the decoded content in bytes. */
     size: number;
@@ -211,16 +236,18 @@ export interface MailParserOptions {
      */
     keepDeliveryStatus?: boolean;
     /**
-     * Decode character sets with the native `iconv` module instead of `iconv-lite`. Pass the
-     * `Iconv` class: `{ Iconv: require('iconv').Iconv }`.
+     * Decode the character sets of text bodies with the native `iconv` module instead of libmime's
+     * decoder (`iconv-lite`). Pass the `Iconv` class: `{ Iconv: require('iconv').Iconv }`. Bodies
+     * declared as UTF-7 are never decoded from it either way, see the note on charsets in the README.
      */
     Iconv?: IconvConstructor;
     /**
      * The hash algorithm for attachment checksums, any name `crypto.createHash()` accepts. An algorithm
-     * that is not available makes the parser emit an error.
+     * that is not available makes the parser emit an error. `false` skips hashing attachments
+     * altogether, and their `checksum` is then not set (`size` still is).
      * @default 'md5'
      */
-    checksumAlgo?: string;
+    checksumAlgo?: string | false;
     /**
      * The longest the URLs `updateImageLinks()` writes into the HTML may be in total, in characters.
      * References past the limit are left as `cid:` links.

package/node_modules/mailparser/dist/esm/address-header.d.ts

@@ -0,0 +1,19 @@
+import type { AddressObject, ParseAddressHeaderOptions } from './types.js';
+/**
+ * Parses the value of an address header (`From`, `To`, `Cc`, `Reply-To` and the like) into the
+ * {@link AddressObject} `MailParser` and `simpleParser` produce for one: display names have their
+ * encoded words decoded, an internationalized (punycode) domain is decoded to Unicode (unless
+ * `decodePunycode` is false), and an
+ * address part that hides an encoded word is dropped unless it decodes to a plain `local@domain`
+ * (RFC 2047 keeps encoded words out of the address, so `=?utf-8?B?...?=@example.com` naming
+ * another address is not taken at its word).
+ *
+ * The value is the header value without the `Name:` prefix, as a string. Line folding may be left
+ * in. Raw 8-bit bytes have to be decoded into the string first, eg. `buffer.toString('utf-8')`.
+ * Several values (a header that occurs more than once) can be given as an array: each is parsed
+ * on its own and the addresses are listed in order.
+ *
+ * @param value The header value, or several of them
+ * @param options See {@link ParseAddressHeaderOptions}
+ */
+export declare function parseAddressHeader(value: string | string[] | null | undefined, options?: ParseAddressHeaderOptions): AddressObject;

package/node_modules/mailparser/dist/esm/address-header.js

@@ -0,0 +1,176 @@
+import he from 'he';
+import libmime from 'libmime';
+import addressparser from 'nodemailer/lib/addressparser';
+import punycode from 'punycode.js';
+// An RFC 2047 encoded word
+const ENCODED_WORD = /[=]\?[^?]+\?[BbQq]\?[^?]*\?[=]/;
+/**
+ * Decodes the addresses addressparser produced, in place: encoded words in display names, an
+ * internationalized (punycode) domain, and the members of a group.
+ *
+ * @internal
+ */
+export function decodeAddresses(addresses, decoder = libmime, decodePunycode = true) {
+    for (let address of addresses) {
+        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
+        // again would report an address the header never carried
+        if (address.name) {
+            try {
+                address.name = decoder.decodeWords(address.name);
+            }
+            catch {
+                //ignore, keep as is
+            }
+        }
+        // Security fix: detect RFC 2047 encoded-words in the address field.
+        // Per RFC 2047 Section 5, encoded-words MUST NOT appear in addr-spec.
+        // If found, decode and validate; reject if result is not a simple local@domain.
+        if (address.address && ENCODED_WORD.test(address.address)) {
+            try {
+                let decodedAddr = decoder.decodeWords(address.address);
+                if (/^[^\s@]+@[^\s@]+$/.test(decodedAddr) && !/[=]\?/.test(decodedAddr)) {
+                    address.address = decodedAddr;
+                }
+                else {
+                    address.address = '';
+                }
+            }
+            catch {
+                address.address = '';
+            }
+        }
+        if (decodePunycode && address.address && /@xn--/.test(address.address)) {
+            try {
+                address.address =
+                    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
+            }
+        }
+        if (address.group) {
+            decodeAddresses(address.group, decoder, decodePunycode);
+        }
+    }
+}
+/**
+ * Formats parsed addresses for an HTML context, every value HTML-escaped.
+ *
+ * @internal
+ */
+export function formatAddressesHTML(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(', ');
+    return formatSingleLevel([].concat(value || []));
+}
+/**
+ * Formats parsed addresses as plain text, display names quoted.
+ *
+ * @internal
+ */
+export function formatAddressesText(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(', ');
+    return formatSingleLevel([].concat(value || []));
+}
+/**
+ * Parses the value of an address header (`From`, `To`, `Cc`, `Reply-To` and the like) into the
+ * {@link AddressObject} `MailParser` and `simpleParser` produce for one: display names have their
+ * encoded words decoded, an internationalized (punycode) domain is decoded to Unicode (unless
+ * `decodePunycode` is false), and an
+ * address part that hides an encoded word is dropped unless it decodes to a plain `local@domain`
+ * (RFC 2047 keeps encoded words out of the address, so `=?utf-8?B?...?=@example.com` naming
+ * another address is not taken at its word).
+ *
+ * The value is the header value without the `Name:` prefix, as a string. Line folding may be left
+ * in. Raw 8-bit bytes have to be decoded into the string first, eg. `buffer.toString('utf-8')`.
+ * Several values (a header that occurs more than once) can be given as an array: each is parsed
+ * on its own and the addresses are listed in order.
+ *
+ * @param value The header value, or several of them
+ * @param options See {@link ParseAddressHeaderOptions}
+ */
+export function parseAddressHeader(value, options) {
+    let addresses = [];
+    for (let entry of [].concat(value)) {
+        if (typeof entry !== 'string' || !entry) {
+            continue;
+        }
+        let parsed = addressparser(entry, { flatten: !!options?.flatten });
+        decodeAddresses(parsed, libmime, options?.decodePunycode !== false);
+        for (let address of parsed) {
+            addresses.push(address);
+        }
+    }
+    return withLazyFormats(addresses);
+}
+/**
+ * The AddressObject for parsed addresses, with `html` and `text` built on first read: a caller
+ * that only wants the addresses (eg. for an SMTP envelope) pays for neither. Both stay enumerable
+ * and assignable, to read, compare, serialize and overwrite like the plain values they were.
+ */
+function withLazyFormats(addresses) {
+    let html;
+    let text;
+    const result = { value: addresses };
+    Object.defineProperties(result, {
+        html: {
+            enumerable: true,
+            get: () => (html ??= formatAddressesHTML(addresses)),
+            set: value => {
+                html = value;
+            }
+        },
+        text: {
+            enumerable: true,
+            get: () => (text ??= formatAddressesText(addresses)),
+            set: value => {
+                text = value;
+            }
+        }
+    });
+    return result;
+}

package/node_modules/mailparser/dist/esm/index.d.ts

@@ -1,10 +1,12 @@
 import MailParser from './mail-parser.js';
 import simpleParser from './simple-parser.js';
-export { MailParser, simpleParser };
+import { parseAddressHeader } from './address-header.js';
+export { MailParser, simpleParser, parseAddressHeader };
 export type { SimpleParserCallback } from './simple-parser.js';
 export type * from './types.js';
 declare const _default: {
     MailParser: typeof MailParser;
     simpleParser: typeof simpleParser;
+    parseAddressHeader: typeof parseAddressHeader;
 };
 export default _default;

package/node_modules/mailparser/dist/esm/index.js

@@ -1,4 +1,5 @@
 import MailParser from './mail-parser.js';
 import simpleParser from './simple-parser.js';
-export { MailParser, simpleParser };
-export default { MailParser, simpleParser };
+import { parseAddressHeader } from './address-header.js';
+export { MailParser, simpleParser, parseAddressHeader };
+export default { MailParser, simpleParser, parseAddressHeader };