@mavogel/awscdk-rootmail 0.1.23 → 0.1.25

package/node_modules/libmime/dist/cjs/package.json

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

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

@@ -0,0 +1,59 @@
+/**
+ * Configuration object of a Libmime instance, kept as `config`. The library itself does not read any keys
+ */
+export type LibmimeConfig = Record<string, any>;
+/**
+ * A single header line split into its key and value
+ */
+export interface HeaderLine {
+    /** Lowercased header key */
+    key: string;
+    /** Header value, unfolded and trimmed, not mime word decoded */
+    value: string;
+}
+/**
+ * Parsed header block, every key holds the values of all the header lines with that key
+ */
+export type HeaderObject = Record<string, string[]>;
+/**
+ * Header value with key=value parameters as returned by parseHeaderValue()
+ */
+export interface ParsedHeaderValue {
+    /** The value in front of the parameters, eg. "text/plain" */
+    value: string;
+    /** Parameters keyed by their lowercased names */
+    params: Record<string, string>;
+    /**
+     * Names of the params assembled from rfc2231 segments. Their values are already decoded,
+     * so a caller that runs decodeWords() over the params has to leave them out. Non-enumerable
+     */
+    decodedParams: string[];
+}
+/**
+ * Header value with parameters as accepted by buildHeaderValue()
+ */
+export interface StructuredHeaderValue {
+    value: string;
+    params?: Record<string, unknown> | undefined;
+}
+/**
+ * A parameter key and value pair as returned by buildHeaderParam()
+ */
+export interface HeaderParam {
+    key: string;
+    value: string;
+}
+/**
+ * Header value with key=value parameters, the name the @types/libmime declarations used
+ */
+export interface StructuredHeader {
+    value: string;
+    params: {
+        [key: string]: string;
+    };
+}
+/**
+ * Encoding of a mime encoded word, Q for quoted printable and B for base64. Lowercase letters
+ * and longer names that start with Q or B are accepted as well
+ */
+export type MimeWordEncoding = 'Q' | 'B';

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

@@ -0,0 +1,4 @@
+"use strict";
+// Public types of the library. Re-exported from the package entry point, and reachable as
+// members of the default export (`libmime.ParsedHeaderValue`) as well
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/libmime/dist/esm/charset.d.ts

@@ -0,0 +1,43 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Encodes an unicode string into an Buffer object as UTF-8
+ *
+ * We force UTF-8 here, no strange encodings allowed.
+ *
+ * @param str String to be encoded
+ * @return UTF-8 encoded typed array
+ */
+export declare function encode(str: string): Buffer;
+/**
+ * Decodes a string from Buffer to an unicode string using specified encoding.
+ * An unknown charset falls back to UTF-8
+ *
+ * @param buf Binary data to be decoded
+ * @param [fromCharset='UTF-8'] Binary data is decoded into string using this charset
+ * @return Decoded string
+ */
+export declare function decode(buf: Buffer | string, fromCharset?: string): string;
+/**
+ * Convert a string from specific encoding to UTF-8 Buffer
+ *
+ * @param data String or Buffer to be encoded
+ * @param [fromCharset='UTF-8'] Source encoding for the string
+ * @return UTF-8 encoded typed array
+ */
+export declare function convert(data: string | Buffer, fromCharset?: string): Buffer;
+/**
+ * Converts well known invalid character set names to proper names.
+ * eg. win-1257 will be converted to windows-1257. Missing or non-string
+ * input defaults to UTF-8.
+ *
+ * @param charset Charset name to convert
+ * @return Canonicalized charset name
+ */
+export declare function normalizeCharset(charset?: unknown): string;
+declare const _default: {
+    encode: typeof encode;
+    decode: typeof decode;
+    convert: typeof convert;
+    normalizeCharset: typeof normalizeCharset;
+};
+export default _default;

package/node_modules/libmime/dist/esm/charset.js

@@ -0,0 +1,125 @@
+import { Buffer } from 'node:buffer';
+import iconv from 'iconv-lite';
+import encodingJapanese from 'encoding-japanese';
+import charsets from './charsets.js';
+/**
+ * Character set encoding and decoding functions
+ */
+// Names that are decoded as UTF-8 without going through iconv-lite
+const UTF8_COMPATIBLE = /^(?:(?:us-)?ascii|utf-8|7bit)$/i;
+// iconv-lite codecs that are not character sets a message could be written in. UTF-7 is a known
+// way to smuggle markup past filters (=?utf-7?Q?+ADw-script+AD4-?= decodes to "<script>"), base64
+// and hex are transfer encodings. A name resolving to one of them is treated like a charset
+// iconv-lite does not know. iconv-lite resolves the name itself and returns one cached codec per
+// encoding, so every alias it knows (unicode-1-1-utf-7 is utf7 too) is caught by identity
+const UNSUPPORTED_CODECS = new Set(['utf7', 'utf7imap', 'base64', 'hex'].map(name => iconv.getCodec(name)));
+const isUnsupportedCodec = (name) => {
+    try {
+        return UNSUPPORTED_CODECS.has(iconv.getCodec(name));
+    }
+    catch (_err) {
+        // a charset iconv-lite does not know at all
+        return false;
+    }
+};
+// Own entries only, so that a name such as '__proto__' or 'constructor' does not resolve to an
+// inherited Object.prototype member
+const CHARSET_ALIASES = new Map(Object.entries(charsets));
+/**
+ * Encodes an unicode string into an Buffer object as UTF-8
+ *
+ * We force UTF-8 here, no strange encodings allowed.
+ *
+ * @param str String to be encoded
+ * @return UTF-8 encoded typed array
+ */
+export function encode(str) {
+    return Buffer.from(str, 'utf-8');
+}
+/**
+ * Decodes a string from Buffer to an unicode string using specified encoding.
+ * An unknown charset falls back to UTF-8
+ *
+ * @param buf Binary data to be decoded
+ * @param [fromCharset='UTF-8'] Binary data is decoded into string using this charset
+ * @return Decoded string
+ */
+export function decode(buf, fromCharset) {
+    fromCharset = normalizeCharset(fromCharset || 'UTF-8');
+    if (UTF8_COMPATIBLE.test(fromCharset)) {
+        return buf.toString('utf-8');
+    }
+    if (isUnsupportedCodec(fromCharset)) {
+        // enforce utf-8, the same as for a charset iconv-lite does not know
+        return buf.toString();
+    }
+    try {
+        if (/^jis|^iso-?2022-?jp|^EUCJP/i.test(fromCharset)) {
+            if (typeof buf === 'string') {
+                buf = Buffer.from(buf);
+            }
+            try {
+                let output = encodingJapanese.convert(buf, {
+                    to: 'UNICODE',
+                    from: fromCharset,
+                    type: 'string'
+                });
+                if (typeof output === 'string') {
+                    return output;
+                }
+                // fall through to iconv-lite if convert returned something unexpected
+            }
+            catch (_err) {
+                // ignore, defaults to iconv-lite on error
+            }
+        }
+        // iconv-lite reads a string as binary, kept as it always was
+        return iconv.decode(buf, fromCharset);
+    }
+    catch (_err) {
+        // enforce utf-8, data loss might occur
+        return buf.toString();
+    }
+}
+/**
+ * Convert a string from specific encoding to UTF-8 Buffer
+ *
+ * @param data String or Buffer to be encoded
+ * @param [fromCharset='UTF-8'] Source encoding for the string
+ * @return UTF-8 encoded typed array
+ */
+export function convert(data, fromCharset) {
+    fromCharset = normalizeCharset(fromCharset || 'UTF-8');
+    if (typeof data !== 'string') {
+        if (UTF8_COMPATIBLE.test(fromCharset)) {
+            return data;
+        }
+        return encode(decode(data, fromCharset));
+    }
+    return encode(data);
+}
+/**
+ * Converts well known invalid character set names to proper names.
+ * eg. win-1257 will be converted to windows-1257. Missing or non-string
+ * input defaults to UTF-8.
+ *
+ * @param charset Charset name to convert
+ * @return Canonicalized charset name
+ */
+export function normalizeCharset(charset) {
+    let name = (charset || 'UTF-8').toString().toLowerCase().trim();
+    // first pass
+    let canonical = CHARSET_ALIASES.get(name);
+    if (canonical) {
+        return canonical;
+    }
+    name = name
+        .replace(/^utf[-_]?(\d+)/, 'utf-$1')
+        .replace(/^(?:us[-_]?)ascii/, 'windows-1252')
+        .replace(/^win(?:dows)?[-_]?(\d+)/, 'windows-$1')
+        .replace(/^(?:latin|iso[-_]?8859)?[-_]?(\d+)/, 'iso-8859-$1')
+        .replace(/^l[-_]?(\d+)/, 'iso-8859-$1');
+    // updated pass
+    return CHARSET_ALIASES.get(name) || name.toUpperCase();
+}
+export default { encode, decode, convert, normalizeCharset };

package/node_modules/libmime/dist/esm/charsets.d.ts

@@ -0,0 +1,2 @@
+declare const charsets: Record<string, string>;
+export default charsets;

package/node_modules/libmime/{lib → dist/esm}/charsets.js

@@ -1,8 +1,5 @@
-/* eslint quote-props: 0*/
-
-'use strict';
-
-module.exports = {
+// Charset name aliases, keyed by the lowercased alias, mapped to the canonical name
+const charsets = {
     '866': 'IBM866',
     'unicode-1-1-utf-8': 'UTF-8',
     'utf-8': 'UTF-8',
@@ -210,3 +207,4 @@ module.exports = {
     'utf-16': 'UTF-16LE',
     'utf-16le': 'UTF-16LE'
 };
+export default charsets;

package/node_modules/libmime/dist/esm/get-charset-name.d.ts

@@ -0,0 +1 @@
+export declare const getCharsetName: (charset: unknown) => string | false;

package/node_modules/libmime/{lib → dist/esm}/get-charset-name.js

@@ -1,5 +1,3 @@
-'use strict';
-
 // https://nodejs.org/api/util.html#encodings-supported-by-default-with-full-icu-data
 // NB! iso-8859-16 not supported
 const CHARSETS = [
@@ -215,13 +213,8 @@ const CHARSETS = [
     'x-sjis',
     'x-x-big5'
 ];
-
 const CHARSET_MAP = new Map(CHARSETS.map(charset => [charset.replace(/[-_]+/g, ''), charset]));
-
-const getCharsetName = charset => {
+export const getCharsetName = (charset) => {
     let charsetKey = (charset || '').toString().toLowerCase().trim().replace(/[-_]+/g, '');
-
     return CHARSET_MAP.get(charsetKey) || false;
 };
-
-module.exports.getCharsetName = getCharsetName;

package/node_modules/libmime/dist/esm/libmime.d.ts

@@ -0,0 +1,219 @@
+import { Buffer } from 'node:buffer';
+import type { HeaderLine, HeaderObject, HeaderParam, LibmimeConfig, ParsedHeaderValue, StructuredHeaderValue } from './types.js';
+import type * as types from './types.js';
+export type * from './types.js';
+export declare class Libmime {
+    config: LibmimeConfig;
+    constructor(config?: LibmimeConfig);
+    /**
+     * Checks if a value is plaintext string (uses only printable 7bit chars)
+     *
+     * When isParam is set the value is destined for a header parameter, so HT, CR and LF
+     * are not plaintext either: a header parameter has no way to carry them. HT is a valid
+     * fold point, so folding and unfolding a header would rewrite it as a space, and CR/LF
+     * cannot appear in a header value at all. DEL is neither a token character nor qtext,
+     * so it can not be carried bare or quoted. Such values have to go through the rfc2231
+     * parameter continuation encoding instead, the same way non-ASCII text does.
+     *
+     * @param {String} value String to be tested
+     * @param {Boolean} [isParam] Set to true if the value is a header parameter value
+     * @returns {Boolean} true if it is a plaintext string
+     */
+    isPlainText(value: unknown, isParam?: boolean): boolean;
+    private isPlainParamValue;
+    /**
+     * Checks if a multi line string containes lines longer than the selected value.
+     *
+     * Useful when detecting if a mail message needs any processing at all:
+     * if only plaintext characters are used and lines are short, then there is
+     * no need to encode the values in any way. If the value is plaintext but has
+     * longer lines then allowed, then use format=flowed
+     *
+     * @param {String} str String to be tested
+     * @param {Number} lineLength Max line length to check for
+     * @returns {Boolean} Returns true if there is at least one line longer than lineLength chars
+     */
+    hasLongerLines(str: string, lineLength: number): boolean;
+    /**
+     * Decodes a string from a format=flowed soft wrapping.
+     *
+     * @param {String} str Plaintext string with format=flowed to decode
+     * @param {Boolean} [delSp] If true, delete leading spaces (delsp=yes)
+     * @return {String} Mime decoded string
+     */
+    decodeFlowed(input: unknown, delSp?: boolean): string;
+    /**
+     * Adds soft line breaks to content marked with format=flowed to
+     * ensure that no line in the message is never longer than lineLength
+     *
+     * @param {String} str Plaintext string that requires wrapping
+     * @param {Number} [lineLength=76] Maximum length of a line
+     * @return {String} String with forced line breaks
+     */
+    encodeFlowed(str: string, lineLength?: number): string;
+    /**
+     * Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047)
+     *
+     * @param {String|Buffer} data String to be encoded
+     * @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+     * @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+     * @return {String} Single or several mime words joined together
+     */
+    encodeWord(data: string | Buffer, mimeWordEncoding?: string, maxLength?: number): string;
+    /**
+     * Normalizes a charset name to its canonical form, resolving common aliases and
+     * invalid names. For example `iso-8859-8-i` and `iso-8859-8-e` become `ISO-8859-8`
+     * and `win-1257` becomes `windows-1257`. Unknown charsets are returned uppercased.
+     * Missing or non-string input defaults to `UTF-8`.
+     *
+     * @param {String} charset Charset name to normalize
+     * @return {String} Canonical charset name
+     */
+    normalizeCharset(charset?: unknown): string;
+    /**
+     * Decodes the inner payload of a single mime encoded-word into a unicode string.
+     * Expects the three components of `=?charset?encoding?text?=` already separated.
+     *
+     * @param {String} charset Charset name from the encoded-word (may include an RFC 2231 language tag, which is ignored)
+     * @param {String} encoding Encoding indicator, either 'Q' or 'B' (case insensitive)
+     * @param {String} str Encoded payload between the second `?` and the trailing `?=`
+     * @return {String} Decoded unicode string
+     */
+    decodeWord(charset: string, encoding: string, str: string): string;
+    /**
+     * Finds word sequences with non ascii text and converts these to mime words
+     *
+     * @param {String|Buffer} data String to be encoded
+     * @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+     * @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+     * @param {String} [fromCharset='UTF-8'] Source character set
+     * @return {String} String with possible mime words
+     */
+    encodeWords(data: string | Buffer, mimeWordEncoding?: string, maxLength?: number | string, fromCharset?: string): string;
+    /**
+     * Decode a string that might include one or several mime words
+     *
+     * @param {String} str String including some mime words that will be decoded
+     * @return {String} Decoded unicode string
+     */
+    decodeWords(str: unknown): string;
+    getHex(c: number | undefined): string | false;
+    /**
+     * Splits a string by :
+     * The result is not mime word decoded, you need to do your own decoding based
+     * on the rules for the specific header key
+     *
+     * @param {String} headerLine Single header line, might include linebreaks as well if folded
+     * @return {Object} An object of {key, value}
+     */
+    decodeHeader(headerLine: unknown): HeaderLine;
+    /**
+     * Parses a block of header lines. Does not decode mime words as every
+     * header might have its own rules (eg. formatted email addresses and such)
+     *
+     * @param {String} headers Headers string
+     * @return {Object} An object of headers, where header keys are object keys and every value is an Array of the values for that key
+     */
+    decodeHeaders(headers: string): HeaderObject;
+    /**
+     * Joins parsed header value together as 'value; param1=value1; param2=value2'
+     * PS: We are following RFC 822 for the list of special characters that we need to keep in quotes.
+     *      Refer: https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
+     * @param {Object} structured Parsed header value
+     * @return {String} joined header value
+     */
+    buildHeaderValue(structured: StructuredHeaderValue): string;
+    /**
+     * Parses a header value with key=value arguments into a structured
+     * object.
+     *
+     *   parseHeaderValue('text/plain; CHARSET=UTF-8') ->
+     *   {
+     *     'value': 'text/plain',
+     *     'params': {
+     *       'charset': 'UTF-8'
+     *     }
+     *   }
+     *
+     * The result also carries a non-enumerable `decodedParams` array that names the params
+     * assembled from rfc2231 segments (title*=, title*0*=, title*0=). Those values are already
+     * decoded, so a caller that runs decodeWords() over the params has to leave them out
+     *
+     * @param {String} str Header value
+     * @return {Object} Header value as a parsed structure
+     */
+    parseHeaderValue(str: string): ParsedHeaderValue;
+    /**
+     * Encodes a string or an Buffer to an UTF-8 Parameter Value Continuation encoding (rfc2231)
+     * Useful for splitting long parameter values.
+     *
+     * For example
+     *      title="unicode string"
+     * becomes
+     *     title*0*=utf-8''unicode
+     *     title*1*=%20string
+     *
+     * @param {String} key Parameter name (eg. 'filename')
+     * @param {String|Buffer} data String to be encoded
+     * @param {Number} [maxLength=50] Max length for generated chunks
+     * @param {String} [fromCharset='UTF-8'] Source character set
+     * @return {Array} A list of encoded keys and headers
+     */
+    buildHeaderParam(key: string, data: unknown, maxLength?: number, fromCharset?: string): HeaderParam[];
+    /**
+     * Returns file extension for a content type string. If no suitable extensions
+     * are found, 'bin' is used as the default extension
+     *
+     * @param {String} mimeType Content type to be checked for
+     * @return {String} File extension
+     */
+    detectExtension(input: unknown): string;
+    /**
+     * Returns content type for a file extension. If no suitable content types
+     * are found, 'application/octet-stream' is used as the default content type
+     *
+     * @param {String} extension Extension (or filename) to be checked for
+     * @return {String} Content type
+     */
+    detectMimeType(input: unknown): string;
+    /**
+     * Folds long lines, useful for folding header lines (afterSpace=false) and
+     * flowed text (afterSpace=true)
+     *
+     * @param {String} str String to be folded
+     * @param {Number} [lineLength=76] Maximum length of a line
+     * @param {Boolean} afterSpace If true, leave a space in the end of a line
+     * @return {String} String with folded lines
+     */
+    foldLines(input: unknown, lineLength?: number, afterSpace?: boolean): string;
+    /**
+     * Splits a mime encoded string. Needed for dividing mime words into smaller chunks
+     *
+     * @param {String} str Mime encoded string to be split up
+     * @param {Number} maxlen Maximum length of characters for one part (minimum 12)
+     * @return {Array} Split string
+     */
+    splitMimeEncodedString(str: string, maxlen?: number): string[];
+    encodeURICharComponent(chr: string): string;
+    safeEncodeURIComponent(input: unknown): string;
+}
+/**
+ * The shared instance, the default export of the package. The class is attached to it as `Libmime`,
+ * so `require('libmime').Libmime` keeps working
+ */
+declare const libmime: Libmime & {
+    Libmime: typeof Libmime;
+};
+type LibmimeInstance = Libmime;
+declare namespace libmime {
+    type Libmime = LibmimeInstance;
+    type HeaderLine = types.HeaderLine;
+    type HeaderObject = types.HeaderObject;
+    type HeaderParam = types.HeaderParam;
+    type LibmimeConfig = types.LibmimeConfig;
+    type MimeWordEncoding = types.MimeWordEncoding;
+    type ParsedHeaderValue = types.ParsedHeaderValue;
+    type StructuredHeader = types.StructuredHeader;
+    type StructuredHeaderValue = types.StructuredHeaderValue;
+}
+export default libmime;