@mavogel/awscdk-rootmail 0.1.25 → 0.1.27

package/node_modules/mailparser/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/node_modules/mailparser/dist/cjs/simple-parser.d.ts

@@ -0,0 +1,17 @@
+import type { ParsedMail, SimpleParserOptions, Source } from './types.js';
+/**
+ * Called with the parsed message, or with the error that stopped parsing.
+ */
+export type SimpleParserCallback = (err: Error | null, mail: ParsedMail) => void;
+/**
+ * Parses a whole message into one object, attachments buffered in memory. Resolves with the
+ * parsed message, or calls `callback` with it when one is given.
+ *
+ * @param input The raw message as a Buffer or a string, or a readable stream of it
+ * @param options Parser options, see {@link SimpleParserOptions}
+ * @throws {TypeError} When `input` is `null` or `undefined`
+ */
+declare function simpleParser(input: Source, callback: SimpleParserCallback): void;
+declare function simpleParser(input: Source, options: SimpleParserOptions | null | undefined, callback: SimpleParserCallback): void;
+declare function simpleParser(input: Source, options?: SimpleParserOptions | null): Promise<ParsedMail>;
+export default simpleParser;

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

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mail_parser_js_1 = __importDefault(require("./mail-parser.js"));
+function simpleParser(input, options, callback) {
+    if (input === null || input === undefined) {
+        throw new TypeError('Input cannot be null or undefined.');
+    }
+    if (!callback && typeof options === 'function') {
+        callback = options;
+        options = false;
+    }
+    let promise;
+    let done;
+    if (!callback) {
+        promise = new Promise((resolve, reject) => {
+            done = (err, mail) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(mail);
+                }
+            };
+        });
+    }
+    else {
+        done = callback;
+    }
+    // MailParser may emit a non-fatal 'error' and still reach 'end', so settle only once:
+    // the first error or the result wins
+    let settled = false;
+    let settle = (...args) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        done(...args);
+    };
+    let parserOptions = options || {};
+    let keepCidLinks = !!parserOptions.keepCidLinks;
+    let mail = {
+        attachments: []
+    };
+    let parser = new mail_parser_js_1.default(parserOptions);
+    parser.on('error', err => {
+        settle(err);
+    });
+    parser.on('headers', headers => {
+        mail.headers = headers;
+        mail.headerLines = parser.headerLines;
+    });
+    let reading = false;
+    let reader = () => {
+        reading = true;
+        let data = parser.read();
+        if (data === null) {
+            reading = false;
+            return;
+        }
+        if (data.type === 'text') {
+            Object.keys(data).forEach(key => {
+                if (['text', 'html', 'textAsHtml', 'textConversionError'].includes(key)) {
+                    mail[key] = data[key];
+                }
+            });
+        }
+        if (data.type === 'attachment') {
+            let attachment = data;
+            mail.attachments.push(attachment);
+            let chunks = [];
+            let chunklen = 0;
+            attachment.content.on('readable', () => {
+                let chunk;
+                while ((chunk = attachment.content.read()) !== null) {
+                    chunks.push(chunk);
+                    chunklen += chunk.length;
+                }
+            });
+            attachment.content.on('end', () => {
+                attachment.content = Buffer.concat(chunks, chunklen);
+                attachment.release();
+                reader();
+            });
+        }
+        else {
+            reader();
+        }
+    };
+    parser.on('readable', () => {
+        if (!reading) {
+            reader();
+        }
+    });
+    parser.on('end', () => {
+        ['subject', 'references', 'date', 'to', 'from', 'to', 'cc', 'bcc', 'message-id', 'in-reply-to', 'reply-to'].forEach(key => {
+            if (mail.headers && mail.headers.has(key)) {
+                mail[key.replace(/-([a-z])/g, (m, c) => c.toUpperCase())] = mail.headers.get(key);
+            }
+        });
+        if (keepCidLinks) {
+            return settle(null, mail);
+        }
+        parser.updateImageLinks((attachment, done) => done(false, 'data:' + attachment.contentType + ';base64,' + attachment.content.toString('base64')), (err, html) => {
+            if (err) {
+                return settle(err);
+            }
+            mail.html = html;
+            settle(null, mail);
+        });
+    });
+    if (typeof input === 'string') {
+        parser.end(Buffer.from(input));
+    }
+    else if (Buffer.isBuffer(input)) {
+        parser.end(input);
+    }
+    else {
+        input
+            .once('error', err => {
+            input.destroy();
+            parser.destroy();
+            settle(err);
+        })
+            .pipe(parser);
+    }
+    return promise;
+}
+exports.default = simpleParser;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

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

@@ -0,0 +1,24 @@
+import crypto from 'node:crypto';
+import { Transform } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
+/**
+ * The object StreamHash records its results on.
+ */
+export interface HashTarget {
+    checksum?: string;
+    size?: number;
+}
+/**
+ * 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.
+ */
+declare class StreamHash extends Transform {
+    attachment: HashTarget;
+    algo: string;
+    hash: crypto.Hash;
+    byteCount: number;
+    constructor(attachment: HashTarget, algo?: string);
+    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
+    _flush(done: TransformCallback): void;
+}
+export default StreamHash;

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ */
+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.byteCount = 0;
+    }
+    _transform(chunk, encoding, done) {
+        this.hash.update(chunk);
+        this.byteCount += chunk.length;
+        done(null, chunk);
+    }
+    _flush(done) {
+        this.attachment.checksum = this.hash.digest('hex');
+        this.attachment.size = this.byteCount;
+        done();
+    }
+}
+exports.default = StreamHash;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/node_modules/mailparser/dist/cjs/tlds.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+// The tlds package ships its list as index.json. An ES module can only import JSON with an import
+// attribute, which Node.js 20 before 20.10 does not parse, so both builds load the list through
+// this CommonJS file instead: require() reads JSON on every Node.js version, and `import` of a
+// CommonJS module gives its module.exports as the default export. scripts/build.js copies it next
+// to the compiled modules.
+module.exports = require('tlds');

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

@@ -0,0 +1,309 @@
+import type { Readable } from 'node:stream';
+/**
+ * A structured header value with parameters, as produced for `Content-Type`,
+ * `Content-Disposition` and `DKIM-Signature`.
+ *
+ * `Content-Type: text/plain; charset="UTF-8"` becomes
+ * `{ value: 'text/plain', params: { charset: 'UTF-8' } }`.
+ */
+export interface StructuredHeader {
+    /** The main value, without parameters. Encoded words are decoded. */
+    value: string;
+    /** Parameters keyed by lowercase name. RFC 2231 and RFC 2047 encoded values are decoded. */
+    params: {
+        [key: string]: string;
+    };
+}
+/**
+ * One mailbox or group of an address header.
+ */
+export interface EmailAddress {
+    /** The display name, or the group name for a group. Empty string when the header gave none. */
+    name: string;
+    /** The address, with an internationalized (punycode) domain decoded to Unicode. Not set for a group. */
+    address?: string;
+    /** The members of a group, when this entry is a group (`Group: a@example.com, b@example.com;`). */
+    group?: EmailAddress[];
+}
+/**
+ * A parsed address header (`From`, `To`, `Cc`, `Bcc`, `Sender`, `Reply-To`, `Delivered-To`,
+ * `Return-Path`, `Disposition-Notification-To`).
+ */
+export interface AddressObject {
+    /** The parsed addresses. */
+    value: EmailAddress[];
+    /** The addresses formatted for an HTML context, with every value HTML-escaped. */
+    html: string;
+    /** The addresses formatted as plain text, display names quoted. */
+    text: string;
+}
+/**
+ * One entry of the combined `list` header, built from a `List-*` header such as `List-Unsubscribe`.
+ */
+export interface ListHeaderEntry {
+    /** An `http:` or `https:` URL from the header. */
+    url?: string;
+    /** A display name from the header. */
+    name?: string;
+    /** An e-mail address from the header, without the `mailto:` prefix. */
+    mail?: string;
+    /** A value without an `@`, such as the `List-Id` identifier. */
+    id?: string;
+}
+/**
+ * The combined `List-*` headers, keyed by the part of the header name after `list-`. For example
+ * `List-Unsubscribe` is found under `unsubscribe` and `List-Id` under `id`.
+ */
+export interface ListHeaders {
+    [key: string]: ListHeaderEntry;
+}
+/**
+ * A parsed header value. What a header parses into depends on its name:
+ *
+ * - address headers are {@link AddressObject} values,
+ * - `Date` is a `Date` (the current time when the header can not be parsed),
+ * - `Content-Type`, `Content-Disposition` and `DKIM-Signature` are {@link StructuredHeader} values,
+ * - `References` is a string, or an array of strings when it lists more than one Message-ID,
+ * - `Priority`, `X-Priority`, `X-MSMail-Priority` and `Importance` are combined into `priority`,
+ *   one of `'high'`, `'normal'` or `'low'`,
+ * - `List-*` headers are combined into `list`, see {@link ListHeaders},
+ * - every other header is its decoded string value.
+ *
+ * A header that is repeated becomes an array of values, except for the headers that can only appear
+ * once (`From`, `Subject`, `Date`, `Message-ID`, `Content-Type` and the like), which keep their first
+ * occurrence.
+ */
+export type HeaderValue = string | string[] | Date | AddressObject | AddressObject[] | StructuredHeader | StructuredHeader[] | ListHeaders;
+/**
+ * Parsed headers keyed by lowercase header name.
+ */
+export type Headers = Map<string, HeaderValue>;
+/**
+ * The raw header lines in the order they appear, with the lowercase header name as `key` and the
+ * unparsed line, folding included, as `line`.
+ */
+export type HeaderLines = ReadonlyArray<{
+    key: string;
+    line: string;
+}>;
+/**
+ * The properties every attachment has, whether streamed by {@link MailParser} or buffered by
+ * `simpleParser`.
+ */
+export interface AttachmentCommon {
+    /** Identifies an attachment among the objects {@link MailParser} emits. */
+    type: 'attachment';
+    /** The MIME type. For `application/octet-stream` it is detected from the file name when there is one. */
+    contentType: string;
+    /** The IMAP style part number (`'1.2'`), or `null` when the message is not multipart. */
+    partId: string | null;
+    /** The `Content-Disposition` value (`'attachment'`, `'inline'` or whatever the message said), if the part had one. */
+    contentDisposition?: string;
+    /** The file name, if the part named one. */
+    filename?: string;
+    /** The parsed MIME headers of the attachment part. */
+    headers: Headers;
+    /** The `Content-ID` value, angle brackets included, if the part had one. */
+    contentId?: string;
+    /** The `Content-ID` value without angle brackets, to match against `cid:` URLs. */
+    cid?: string;
+    /** `true` when the part has a `Content-ID` and sits inside `multipart/related`, such as an embedded image. */
+    related?: boolean;
+}
+/**
+ * An attachment as {@link MailParser} emits it: the content is a stream that has to be read, and
+ * `release()` called, before the parser continues.
+ */
+export interface AttachmentStream extends AttachmentCommon {
+    /** The decoded attachment content. */
+    content: Readable;
+    /**
+     * Tells the parser the attachment has been handled, so it can continue with the rest of the
+     * 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. */
+    checksum?: string;
+    /** The size of the decoded content in bytes. Set once `content` has ended. */
+    size?: number;
+}
+/**
+ * An attachment as `simpleParser` returns it, with the content buffered in memory.
+ */
+export interface Attachment extends AttachmentCommon {
+    /** The decoded attachment content. */
+    content: Buffer;
+    /** Always `null`, `simpleParser` has released the attachment already. */
+    release: null;
+    /** The hex encoded checksum of the content (md5 unless `checksumAlgo` says otherwise). */
+    checksum: string;
+    /** The size of the decoded content in bytes. */
+    size: number;
+}
+/**
+ * The text content {@link MailParser} emits once, after the whole message has been parsed.
+ */
+export interface MessageText {
+    /** Identifies the text content among the objects {@link MailParser} emits. */
+    type: 'text';
+    /**
+     * The HTML content: every `text/html` part, with plain text parts outside `multipart/alternative`
+     * converted to HTML. Not set when the message has no HTML part.
+     */
+    html?: string;
+    /**
+     * The plain text content: every `text/plain` part, with HTML converted to text where there is no
+     * plain text alternative. Not set when the message has no text at all.
+     */
+    text?: string;
+    /** The plain text content converted to HTML, links included. Set whenever `text` is. */
+    textAsHtml?: string;
+    /**
+     * Why an HTML part could not be converted to text: it was longer than `maxHtmlLengthToParse`,
+     * nested deeper than the converter can handle, or the converter failed. The text of that part is
+     * empty, everything else is parsed as usual.
+     */
+    textConversionError?: Error;
+}
+/**
+ * The `Iconv` class of the `iconv` package, or anything with the same interface.
+ */
+export interface IconvConstructor {
+    new (fromCharset: string, toCharset: string): NodeJS.ReadWriteStream;
+}
+/**
+ * Options for {@link MailParser}. `simpleParser` takes the same options plus `keepCidLinks`.
+ */
+export interface MailParserOptions {
+    /**
+     * Do not convert HTML to plain text when the message has no plain text part.
+     * @default false
+     */
+    skipHtmlToText?: boolean;
+    /**
+     * HTML parts longer than this many characters are not converted to plain text, see
+     * {@link MessageText.textConversionError}. No limit by default.
+     */
+    maxHtmlLengthToParse?: number;
+    /**
+     * Formats the `Date` header of embedded `message/rfc822` parts in the generated text and HTML.
+     * By default `date.toUTCString()` is used.
+     */
+    formatDateString?: (date: Date) => string;
+    /**
+     * Do not replace `cid:` links in the HTML when `updateImageLinks()` (and so `simpleParser`) runs.
+     * @default false
+     */
+    skipImageLinks?: boolean;
+    /**
+     * Do not generate `textAsHtml`, and leave plain text parts out of `html`.
+     * @default false
+     */
+    skipTextToHtml?: boolean;
+    /**
+     * Do not turn URLs, e-mail addresses and `@mentions` into links in `textAsHtml`.
+     * @default false
+     */
+    skipTextLinks?: boolean;
+    /**
+     * Treat `message/delivery-status` parts as attachments instead of adding them to the text content.
+     * @default false
+     */
+    keepDeliveryStatus?: boolean;
+    /**
+     * Decode character sets with the native `iconv` module instead of `iconv-lite`. Pass the
+     * `Iconv` class: `{ Iconv: require('iconv').Iconv }`.
+     */
+    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.
+     * @default 'md5'
+     */
+    checksumAlgo?: string;
+    /**
+     * The longest the URLs `updateImageLinks()` writes into the HTML may be in total, in characters.
+     * References past the limit are left as `cid:` links.
+     * @default 20971520 (20 MB)
+     */
+    maxInlinedImagesSize?: number;
+    /**
+     * Never parse embedded `message/rfc822` parts, keep every one of them as an attachment.
+     * @default false
+     */
+    ignoreEmbedded?: boolean;
+    /**
+     * Parse an embedded message unless its disposition says `attachment`. By default only an embedded
+     * message with an `inline` disposition is parsed, any other is kept as an attachment.
+     * @default false
+     */
+    defaultInlineEmbedded?: boolean;
+    /**
+     * The largest header block of one MIME part, in bytes. A larger one makes the parser emit an error.
+     * @default 1048576 (1 MB)
+     */
+    maxHeadSize?: number;
+    /**
+     * The most MIME parts a message may have. More make the parser emit an error.
+     * @default 1000
+     */
+    maxChildNodes?: number;
+}
+/**
+ * Options for `simpleParser`.
+ */
+export interface SimpleParserOptions extends MailParserOptions {
+    /**
+     * Leave `cid:` links in the HTML as they are. By default every `cid:` link to an image attachment
+     * is replaced with a `data:` URL of the image.
+     * @default false
+     */
+    keepCidLinks?: boolean;
+}
+/**
+ * The parsed message `simpleParser` resolves with.
+ */
+export interface ParsedMail {
+    /** Every attachment, content buffered. */
+    attachments: Attachment[];
+    /** Parsed headers of the message, see {@link HeaderValue}. */
+    headers: Headers;
+    /** The raw header lines of the message. */
+    headerLines: HeaderLines;
+    /**
+     * The HTML content, see {@link MessageText.html}. Unless `keepCidLinks` is set, `cid:` links to
+     * image attachments are replaced with `data:` URLs, and the value is `false` when the message has no
+     * HTML; with `keepCidLinks` set it is not set instead.
+     */
+    html?: string | false;
+    /** The plain text content, see {@link MessageText.text}. */
+    text?: string;
+    /** The plain text content converted to HTML, see {@link MessageText.textAsHtml}. */
+    textAsHtml?: string;
+    /** Why an HTML part could not be converted to text, see {@link MessageText.textConversionError}. */
+    textConversionError?: Error;
+    /** The `Subject` header. */
+    subject?: string;
+    /** The `References` header: one Message-ID as a string, more than one as an array. */
+    references?: string | string[];
+    /** The `Date` header. */
+    date?: Date;
+    /** The `To` header, an array when the message has more than one `To` header. */
+    to?: AddressObject | AddressObject[];
+    /** The `From` header. */
+    from?: AddressObject;
+    /** The `Cc` header, an array when the message has more than one `Cc` header. */
+    cc?: AddressObject | AddressObject[];
+    /** The `Bcc` header, an array when the message has more than one `Bcc` header. */
+    bcc?: AddressObject | AddressObject[];
+    /** The `Message-ID` header, angle brackets included. */
+    messageId?: string;
+    /** The `In-Reply-To` header, angle brackets included. */
+    inReplyTo?: string;
+    /** The `Reply-To` header. */
+    replyTo?: AddressObject;
+}
+/**
+ * A message to parse: the raw message as a Buffer or a string, or a readable stream of it.
+ */
+export type Source = Buffer | string | Readable;

package/node_modules/mailparser/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

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

package/node_modules/mailparser/dist/esm/mail-parser.d.ts

@@ -0,0 +1,98 @@
+import { Transform } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
+import type { AddressObject, AttachmentStream, EmailAddress, HeaderLines, Headers, MailParserOptions, MessageText } from './types.js';
+/**
+ * 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.
+ */
+declare class MailParser extends Transform {
+    /** The options the parser was created with. */
+    options: MailParserOptions;
+    /** The parsed headers of the message, `false` until they have been parsed. */
+    headers: Headers | false;
+    /** The raw header lines of the message, `false` until they have been parsed. */
+    headerLines: HeaderLines | false;
+    /** The plain text content, `false` until the message has been parsed or when there is none. */
+    text: string | false;
+    /** The HTML content, `false` until the message has been parsed or when there is none. */
+    html: string | false;
+    /** The plain text content as HTML, `false` until the message has been parsed or when there is none. */
+    textAsHtml: string | false;
+    /** The `Subject` header, set once the headers have been parsed. */
+    subject?: string;
+    /** The `References` header, set once the headers have been parsed. */
+    references?: string | string[];
+    /** The `Date` header, set once the headers have been parsed. */
+    date?: Date;
+    /** The `To` header, set once the headers have been parsed. */
+    to?: AddressObject | AddressObject[];
+    /** The `From` header, set once the headers have been parsed. */
+    from?: AddressObject;
+    /** The `Cc` header, set once the headers have been parsed. */
+    cc?: AddressObject | AddressObject[];
+    /** The `Bcc` header, set once the headers have been parsed. */
+    bcc?: AddressObject | AddressObject[];
+    /** The `Message-ID` header, set once the headers have been parsed. */
+    messageId?: string;
+    /** The `In-Reply-To` header, set once the headers have been parsed. */
+    inReplyTo?: string;
+    /** The `Reply-To` header, set once the headers have been parsed. */
+    replyTo?: AddressObject;
+    constructor(config?: MailParserOptions);
+    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
+    _flush(done: TransformCallback): void;
+    /**
+     * Turns a `Priority`, `X-Priority`, `X-MSMail-Priority` or `Importance` header value into
+     * `'high'`, `'normal'` or `'low'`.
+     */
+    parsePriority(value: string): 'high' | 'normal' | 'low';
+    /**
+     * Wraps a Message-ID in angle brackets where they are missing. Returns `false` for an empty value.
+     */
+    ensureMessageIDFormat(value: string): string | false;
+    /**
+     * Formats parsed addresses for an HTML context, every value HTML-escaped.
+     */
+    getAddressesHTML(value: EmailAddress | EmailAddress[]): string;
+    /**
+     * Formats parsed addresses as plain text, display names quoted.
+     */
+    getAddressesText(value: EmailAddress | EmailAddress[]): string;
+    /**
+     * 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: (attachment: AttachmentStream, callback: (err: Error | null | false | undefined, url?: string) => void) => void, done: (err: Error | null, html?: string | false) => void): void;
+    /**
+     * 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: string): string;
+}
+interface MailParser {
+    /** Emitted once with the parsed headers of the message. */
+    on(event: 'headers', listener: (headers: Headers) => void): this;
+    /** Emitted once with the raw header lines of the message. */
+    on(event: 'headerLines', listener: (headerLines: HeaderLines) => void): this;
+    /** Emitted for every attachment and, at the end, once for the text content. */
+    on(event: 'data', listener: (data: AttachmentStream | MessageText) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once(event: 'headers', listener: (headers: Headers) => void): this;
+    once(event: 'headerLines', listener: (headerLines: HeaderLines) => void): this;
+    once(event: 'data', listener: (data: AttachmentStream | MessageText) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** Returns the next attachment or text content object, or `null` when none is buffered. */
+    read(size?: number): AttachmentStream | MessageText | null;
+}
+export default MailParser;