@mavogel/awscdk-rootmail 0.1.25 → 0.1.27

package/node_modules/mailparser/dist/esm/package.json

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

package/node_modules/mailparser/dist/esm/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/{lib → dist/esm}/simple-parser.js

@@ -1,65 +1,60 @@
-'use strict';
-
-const MailParser = require('./mail-parser.js');
-
-module.exports = (input, options, callback) => {
+import MailParser from './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) => {
-            callback = callbackPromise(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 = callback;
-    callback = (...args) => {
+    let settle = (...args) => {
         if (settled) {
             return;
         }
         settled = true;
-        settle(...args);
+        done(...args);
     };
-
-    options = options || {};
-    let keepCidLinks = !!options.keepCidLinks;
-
+    let parserOptions = options || {};
+    let keepCidLinks = !!parserOptions.keepCidLinks;
     let mail = {
         attachments: []
     };
-
-    let parser = new MailParser(options);
-
+    let parser = new MailParser(parserOptions);
     parser.on('error', err => {
-        callback(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)) {
@@ -67,83 +62,65 @@ module.exports = (input, options, callback) => {
                 }
             });
         }
-
         if (data.type === 'attachment') {
-            mail.attachments.push(data);
-
+            let attachment = data;
+            mail.attachments.push(attachment);
             let chunks = [];
             let chunklen = 0;
-            data.content.on('readable', () => {
+            attachment.content.on('readable', () => {
                 let chunk;
-                while ((chunk = data.content.read()) !== null) {
+                while ((chunk = attachment.content.read()) !== null) {
                     chunks.push(chunk);
                     chunklen += chunk.length;
                 }
             });
-
-            data.content.on('end', () => {
-                data.content = Buffer.concat(chunks, chunklen);
-                data.release();
+            attachment.content.on('end', () => {
+                attachment.content = Buffer.concat(chunks, chunklen);
+                attachment.release();
                 reader();
             });
-        } else {
+        }
+        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 callback(null, mail);
+            return settle(null, mail);
         }
-        parser.updateImageLinks(
-            (attachment, done) => done(false, 'data:' + attachment.contentType + ';base64,' + attachment.content.toString('base64')),
-            (err, html) => {
-                if (err) {
-                    return callback(err);
-                }
-                mail.html = html;
-
-                callback(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)) {
+    }
+    else if (Buffer.isBuffer(input)) {
         parser.end(input);
-    } else {
+    }
+    else {
         input
             .once('error', err => {
-                input.destroy();
-                parser.destroy();
-                callback(err);
-            })
+            input.destroy();
+            parser.destroy();
+            settle(err);
+        })
             .pipe(parser);
     }
-
     return promise;
-};
-
-function callbackPromise(resolve, reject) {
-    return function (...args) {
-        let err = args.shift();
-        if (err) {
-            reject(err);
-        } else {
-            resolve(...args);
-        }
-    };
 }
+export default simpleParser;

package/node_modules/mailparser/dist/esm/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/{lib → dist/esm}/stream-hash.js

@@ -1,8 +1,9 @@
-'use strict';
-
-const crypto = require('crypto');
-const Transform = require('stream').Transform;
-
+import crypto from 'node:crypto';
+import { Transform } from '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 Transform {
     constructor(attachment, algo) {
         super();
@@ -11,18 +12,15 @@ class StreamHash extends Transform {
         this.hash = crypto.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();
     }
 }
-
-module.exports = StreamHash;
+export default StreamHash;

package/node_modules/mailparser/dist/esm/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/esm/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/esm/types.js

@@ -0,0 +1 @@
+export {};