@mavogel/awscdk-rootmail 0.1.27 → 0.1.28

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

@@ -45,6 +45,26 @@ const libcharset = __importStar(require("./charset.js"));
 const mimetypes = __importStar(require("./mimetypes.js"));
 const STAGE_KEY = 0x1001;
 const STAGE_VALUE = 0x1002;
+/**
+ * Offset of the ")" that closes the rfc822 comment opening at `start`, or -1 when the
+ * comment never closes. Comments nest, and a backslash escapes the character after it
+ */
+const findCommentEnd = (str, start) => {
+    let depth = 0;
+    for (let i = start, len = str.length; i < len; i++) {
+        let chr = str.charAt(i);
+        if (chr === '\\') {
+            i++;
+        }
+        else if (chr === '(') {
+            depth++;
+        }
+        else if (chr === ')' && --depth === 0) {
+            return i;
+        }
+    }
+    return -1;
+};
 // Sets an own property on a plain object. A regular assignment with a
 // '__proto__' key would silently modify the object's prototype instead of
 // creating an own property, so it needs special handling.
@@ -61,6 +81,9 @@ const setOwnProperty = (obj, key, value) => {
         obj[key] = value;
     }
 };
+// Header names decodeHeaders() leaves out with the skipPrototypeKeys option. Keys are lowercased,
+// so of these only '__proto__' and 'constructor' can ever match
+const PROTOTYPE_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
 // Whitespace that separates the tokens of a header value. Kept as a char comparison,
 // a regex test would be run for every single char of every parsed header
 const isWSP = (chr) => chr === ' ' || chr === '\t' || chr === '\r' || chr === '\n' || chr === '\f' || chr === '\v';
@@ -298,6 +321,18 @@ class Libmime {
     normalizeCharset(charset) {
         return libcharset.normalizeCharset(charset);
     }
+    /**
+     * Creates a Transform stream that decodes a body in the given charset into UTF-8 Buffers,
+     * resolving the charset name and handling the Japanese charsets the same way header
+     * decoding does. An unknown or refused charset (UTF-7, base64, hex) is decoded as UTF-8,
+     * and the stream says so with `supported` set to false.
+     *
+     * @param {String} [charset='UTF-8'] Charset the input is encoded in
+     * @return {DecodeStream} Transform stream with `charset` and `supported` properties
+     */
+    createDecodeStream(charset) {
+        return libcharset.createDecodeStream(charset);
+    }
     /**
      * Decodes the inner payload of a single mime encoded-word into a unicode string.
      * Expects the three components of `=?charset?encoding?text?=` already separated.
@@ -456,9 +491,11 @@ class Libmime {
      * header might have its own rules (eg. formatted email addresses and such)
      *
      * @param {String} headers Headers string
+     * @param {Object} [options] Options
+     * @param {Boolean} [options.skipPrototypeKeys] Leave out headers named like an Object.prototype member, eg. `__proto__` and `constructor`
      * @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) {
+    decodeHeaders(headers, options) {
         let lines = headers.split(/\r?\n|\r/), headersObj = {}, header, i, len;
         // Empty lines in front of the block are not part of any header, a caller might
         // include the line break that separates a mime part boundary from its headers
@@ -484,6 +521,9 @@ class Libmime {
         lines = unfolded;
         for (i = 0, len = lines.length; i < len; i++) {
             header = this.decodeHeader(lines[i]);
+            if (options?.skipPrototypeKeys && PROTOTYPE_KEYS.has(header.key)) {
+                continue;
+            }
             // own properties only, an attacker controlled key such as '__proto__' or 'toString' would
             // otherwise resolve to an inherited Object.prototype member
             if (!Object.hasOwn(headersObj, header.key)) {
@@ -552,9 +592,12 @@ class Libmime {
      * decoded, so a caller that runs decodeWords() over the params has to leave them out
      *
      * @param {String} str Header value
+     * @param {Object} [options] Options, see ParseHeaderValueOptions
      * @return {Object} Header value as a parsed structure
      */
-    parseHeaderValue(str) {
+    parseHeaderValue(str, options) {
+        // Cleared again by an unclosed "(", see the loop
+        let stripComments = !!options?.stripComments;
         let response = {
             value: '',
             params: {}
@@ -574,10 +617,23 @@ class Libmime {
         let valueEnd = 0;
         let stage = STAGE_VALUE;
         let quote = false;
+        // A quoted string has closed and the ";" that ends the parameter has not come yet
+        let quoteClosed = false;
         let escaped = false;
         let chr;
+        // Whether a "(" would continue the unquoted token of a parameter value, which it does
+        // right behind the "=" and behind a character of the token: `filename=Invoice(1).pdf`
+        // names the file and `boundary=(c)b` the boundary `(c)b`, as they do for Python and
+        // postal-mime. Anywhere else, in the type, in a parameter name, behind whitespace or
+        // behind a quoted string, a "(" opens a comment
+        let tokenOpen = false;
         // Stores the collected value, either as the default value, as the value for the
-        // current key, or as a key that has no value at all. Runs once per parameter
+        // current key, or as a key that has no value at all. Runs once per parameter.
+        //
+        // A parameter given twice keeps its first value, as it does for Python and for
+        // postal-mime. Letting the last one win read `boundary=b; boundary=c` as a multipart
+        // of the parts under `--c`, which the other readers leave in the epilogue of the
+        // parts under `--b`
         let commit = () => {
             let collected = value.substring(0, valueEnd);
             value = '';
@@ -585,21 +641,42 @@ class Libmime {
             if (stage === STAGE_KEY) {
                 // key without a value, see emptykey:
                 // Header-Key: somevalue; key=value; emptykey
-                if (collected) {
-                    setOwnProperty(response.params, collected.toLowerCase(), '');
+                let name = collected.toLowerCase();
+                if (name && !Object.hasOwn(response.params, name)) {
+                    setOwnProperty(response.params, name, '');
                 }
             }
             else if (key === false) {
                 // default value
                 response.value = collected;
             }
-            else {
+            else if (!Object.hasOwn(response.params, key)) {
                 // subkey value
                 setOwnProperty(response.params, key, collected);
             }
         };
         for (let i = 0, len = str.length; i < len; i++) {
             chr = str.charAt(i);
+            // With stripComments, an rfc822 comment stands anywhere outside a quoted string
+            // but right behind a token it would continue. Read as content, `boundary=b (comment)`
+            // named a boundary no delimiter line matches, so the parts that Python and
+            // postal-mime find stayed hidden from a splitter built on this
+            if (stripComments && chr === '(' && !quote && !escaped && !tokenOpen) {
+                let end = findCommentEnd(str, i);
+                if (end < 0 && str.indexOf(';', i) < 0) {
+                    // A comment that never closes runs to the end of the value, as it does for
+                    // Python. One that a parameter follows is content instead, with everything
+                    // after it, so that the parameter survives, as postal-mime keeps it
+                    end = len - 1;
+                }
+                if (end >= 0) {
+                    i = end;
+                    continue;
+                }
+                // Looking for a closing ")" again would scan a run of unclosed "(" to its end
+                // once for each of them
+                stripComments = false;
+            }
             switch (stage) {
                 case STAGE_KEY:
                     if (chr === '=') {
@@ -607,6 +684,7 @@ class Libmime {
                         value = '';
                         valueEnd = 0;
                         stage = STAGE_VALUE;
+                        tokenOpen = true;
                     }
                     else if (chr === ';') {
                         // key without a value, eg. the "inline" in "attachment; inline; filename=a.txt"
@@ -623,9 +701,19 @@ class Libmime {
                     }
                     break;
                 case STAGE_VALUE:
+                    if (quoteClosed && chr !== ';') {
+                        // Nothing behind a closed quoted string reaches the value: a parameter
+                        // value is a token or a quoted string, not both (rfc2045 section 5.1),
+                        // so what follows one is junk up to the ";" that ends the parameter, as
+                        // Python and postal-mime read it. Read on, `boundary="b"c` named a
+                        // boundary bc that no delimiter line of the message matches
+                        escaped = false;
+                        break;
+                    }
                     if (escaped) {
                         value += chr;
                         valueEnd = value.length;
+                        tokenOpen = key !== false && !quote;
                     }
                     else if (chr === '\\') {
                         escaped = true;
@@ -633,20 +721,26 @@ class Libmime {
                     }
                     else if (chr === '"') {
                         // every char between the quotes is significant, including whitespace
+                        quoteClosed = quote;
                         quote = !quote;
+                        tokenOpen = false;
                     }
                     else if (!quote && chr === ';') {
                         commit();
                         stage = STAGE_KEY;
+                        tokenOpen = false;
+                        quoteClosed = false;
                     }
                     else if (!quote && isWSP(chr)) {
                         if (value.length) {
                             value += chr;
                         }
+                        tokenOpen = false;
                     }
                     else {
                         value += chr;
                         valueEnd = value.length;
+                        tokenOpen = key !== false && !quote;
                     }
                     escaped = false;
                     break;

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

@@ -15,6 +15,34 @@ export interface HeaderLine {
  * Parsed header block, every key holds the values of all the header lines with that key
  */
 export type HeaderObject = Record<string, string[]>;
+/**
+ * Options of decodeHeaders()
+ */
+export interface DecodeHeadersOptions {
+    /**
+     * Leave out the headers whose name is also the name of an Object.prototype member, such as
+     * `__proto__` and `constructor`. By default they are kept as own properties of the result,
+     * where a lookup with the `in` operator or a merge into another object can not tell them
+     * apart from the inherited members
+     */
+    skipPrototypeKeys?: boolean | undefined;
+}
+/**
+ * Options of parseHeaderValue()
+ */
+export interface ParseHeaderValueOptions {
+    /**
+     * Drop the RFC 822 comments outside quoted strings. The MIME headers (Content-Type,
+     * Content-Disposition) allow them and they are not part of the value, so `boundary=b (comment)`
+     * names the boundary `b`. A parenthesis right behind the `=` of a parameter or behind a token
+     * of its value continues the token, as it does for Python and postal-mime: `filename=Invoice(1).pdf`
+     * keeps its name and `boundary=(c)b` names the boundary `(c)b`. A comment that never closes runs to the end
+     * of the value, unless a parameter follows it, in which case it is content and the parameter
+     * survives. By default comments are kept as they are, since a header such as
+     * Authentication-Results carries information in them
+     */
+    stripComments?: boolean | undefined;
+}
 /**
  * Header value with key=value parameters as returned by parseHeaderValue()
  */

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

@@ -1,4 +1,6 @@
 import { Buffer } from 'node:buffer';
+import { Transform } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
 /**
  * Encodes an unicode string into an Buffer object as UTF-8
  *
@@ -34,10 +36,44 @@ export declare function convert(data: string | Buffer, fromCharset?: string): Bu
  * @return Canonicalized charset name
  */
 export declare function normalizeCharset(charset?: unknown): string;
+/**
+ * Transform stream that decodes bytes in a charset into UTF-8 Buffers, see createDecodeStream()
+ */
+export declare class DecodeStream extends Transform {
+    /** Canonical name of the charset the input was declared in, what normalizeCharset() gives */
+    readonly charset: string;
+    /**
+     * false when the declared charset is unknown, or one that is refused (UTF-7, base64, hex). The
+     * input is then decoded as UTF-8, the same fallback decode() applies, so a caller that must
+     * not relabel such bytes as UTF-8 checks this before piping anything through
+     */
+    readonly supported: boolean;
+    private decoder;
+    private chunks;
+    private highSurrogate;
+    constructor(charset?: unknown);
+    _transform(chunk: Buffer, _encoding: BufferEncoding, done: TransformCallback): void;
+    _flush(done: TransformCallback): void;
+    private pushText;
+}
+/**
+ * Creates a Transform stream that decodes bytes in the given charset into UTF-8 Buffers. The
+ * charset name is resolved with normalizeCharset(), and the output is what decode() gives for
+ * the whole input, however it is split into chunks: the Japanese charsets iconv-lite does not
+ * support are decoded with encoding-japanese (collected until the input ends, as that decoder
+ * is not incremental), and an unknown or refused charset (UTF-7, base64, hex) is decoded as
+ * UTF-8 with `supported` set to false on the stream.
+ *
+ * @param [charset='UTF-8'] Charset the input is encoded in
+ * @return Transform stream with `charset` and `supported` properties
+ */
+export declare function createDecodeStream(charset?: unknown): DecodeStream;
 declare const _default: {
     encode: typeof encode;
     decode: typeof decode;
     convert: typeof convert;
     normalizeCharset: typeof normalizeCharset;
+    createDecodeStream: typeof createDecodeStream;
+    DecodeStream: typeof DecodeStream;
 };
 export default _default;

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

@@ -1,4 +1,6 @@
 import { Buffer } from 'node:buffer';
+import { Transform } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
 import iconv from 'iconv-lite';
 import encodingJapanese from 'encoding-japanese';
 import charsets from './charsets.js';
@@ -22,6 +24,8 @@ const isUnsupportedCodec = (name) => {
         return false;
     }
 };
+// Charsets iconv-lite does not support, decoded with encoding-japanese instead
+const JAPANESE_CHARSET = /^jis|^iso-?2022-?jp|^EUCJP/i;
 // 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));
@@ -54,7 +58,7 @@ export function decode(buf, fromCharset) {
         return buf.toString();
     }
     try {
-        if (/^jis|^iso-?2022-?jp|^EUCJP/i.test(fromCharset)) {
+        if (JAPANESE_CHARSET.test(fromCharset)) {
             if (typeof buf === 'string') {
                 buf = Buffer.from(buf);
             }
@@ -122,4 +126,160 @@ export function normalizeCharset(charset) {
     // updated pass
     return CHARSET_ALIASES.get(name) || name.toUpperCase();
 }
-export default { encode, decode, convert, normalizeCharset };
+// The decoder all of iconv-lite's double byte codecs share
+const DBCS_DECODER = iconv.getCodec('gbk').decoder;
+// The UTF-16 and UTF-32 decoders without a byte order in the name read it from a BOM or guess it
+// from the first 100 characters, but a stream guesses as soon as it has 16 or 32 bytes. Holding
+// back this many bytes makes the stream guess from the same characters as decode()
+const BYTE_ORDER_GUESSING = new Map([
+    [iconv.getCodec('utf-16'), 200],
+    [iconv.getCodec('utf-32'), 400]
+]);
+// iconv-lite 0.7 sizes what a DBCS decoder's write() returns by the length of the chunk, so when
+// the chunk finishes or rejects a character the previous one started, the output can outgrow
+// that size and its end is cut off: an astral GB18030 character split in two loses its low
+// surrogate, a GB18030 lead byte followed by a space loses everything after it. The input is
+// therefore cut where no character can be unfinished, right after a byte below 0x30. No lead,
+// trail or GB18030 digit byte is that low, so such a byte always decodes as itself and the
+// parse starts afresh after it. Every cut is decoded as a whole, with nothing carried over, and
+// the bytes after the last such byte wait for the next chunk
+class LowByteCutDecoder {
+    constructor(charset) {
+        this.pending = [];
+        this.charset = charset;
+    }
+    write(chunk) {
+        let cut = chunk.length;
+        while (cut > 0 && chunk[cut - 1] >= 0x30) {
+            cut--;
+        }
+        if (!cut) {
+            // copied, the caller may reuse the chunk it wrote
+            this.pending.push(Buffer.from(chunk));
+            return '';
+        }
+        let text = iconv.decode(Buffer.concat([...this.pending, chunk.subarray(0, cut)]), this.charset);
+        this.pending = [Buffer.from(chunk.subarray(cut))];
+        return text;
+    }
+    end() {
+        let rest = Buffer.concat(this.pending);
+        this.pending = [];
+        return rest.length ? iconv.decode(rest, this.charset) : undefined;
+    }
+}
+// Passes the input on once its first `size` bytes are in, see BYTE_ORDER_GUESSING
+class HeadBufferedDecoder {
+    constructor(decoder, size) {
+        this.head = [];
+        this.headLength = 0;
+        this.decoder = decoder;
+        this.size = size;
+    }
+    write(chunk) {
+        if (!this.head) {
+            return this.decoder.write(chunk);
+        }
+        // copied, the caller may reuse the chunk it wrote
+        this.head.push(Buffer.from(chunk));
+        this.headLength += chunk.length;
+        return this.headLength < this.size ? '' : this.releaseHead();
+    }
+    end() {
+        return (this.head ? this.releaseHead() : '') + (this.decoder.end() || '');
+    }
+    releaseHead() {
+        let head = Buffer.concat(this.head || []);
+        this.head = null;
+        return this.decoder.write(head);
+    }
+}
+// Picks the decoder for a charset iconv-lite knows
+function createChunkDecoder(charset) {
+    let codec = iconv.getCodec(charset);
+    if (codec.decoder === DBCS_DECODER) {
+        return new LowByteCutDecoder(charset);
+    }
+    let headSize = BYTE_ORDER_GUESSING.get(codec);
+    return headSize ? new HeadBufferedDecoder(iconv.getDecoder(charset), headSize) : iconv.getDecoder(charset);
+}
+/**
+ * Transform stream that decodes bytes in a charset into UTF-8 Buffers, see createDecodeStream()
+ */
+export class DecodeStream extends Transform {
+    constructor(charset) {
+        super();
+        // null for the Japanese charsets, which are collected and decoded when the input ends
+        this.decoder = null;
+        this.chunks = [];
+        this.highSurrogate = '';
+        this.charset = normalizeCharset(charset || 'UTF-8');
+        if (UTF8_COMPATIBLE.test(this.charset)) {
+            this.supported = true;
+            this.decoder = new StringDecoder('utf-8');
+        }
+        else if (isUnsupportedCodec(this.charset) || !(JAPANESE_CHARSET.test(this.charset) || iconv.encodingExists(this.charset))) {
+            this.supported = false;
+            this.decoder = new StringDecoder('utf-8');
+        }
+        else {
+            this.supported = true;
+            // encoding-japanese has no incremental decoder and ISO-2022-JP is stateful, so the
+            // Japanese charsets are left without one
+            this.decoder = JAPANESE_CHARSET.test(this.charset) ? null : createChunkDecoder(this.charset);
+        }
+    }
+    _transform(chunk, _encoding, done) {
+        if (!this.decoder) {
+            this.chunks.push(chunk);
+            return done();
+        }
+        try {
+            this.pushText(this.decoder.write(chunk), false);
+        }
+        catch (err) {
+            return done(err);
+        }
+        done();
+    }
+    _flush(done) {
+        try {
+            this.pushText(this.decoder ? this.decoder.end() : decode(Buffer.concat(this.chunks), this.charset), true);
+        }
+        catch (err) {
+            return done(err);
+        }
+        this.chunks = [];
+        done();
+    }
+    // A decoder may return the two halves of a surrogate pair from separate writes, and a lone
+    // half would turn into U+FFFD on its way to UTF-8, so a trailing high surrogate waits for
+    // the rest of its character
+    pushText(text, final) {
+        text = this.highSurrogate + (text || '');
+        this.highSurrogate = '';
+        let last = text.charCodeAt(text.length - 1);
+        if (!final && last >= 0xd800 && last <= 0xdbff) {
+            this.highSurrogate = text.slice(-1);
+            text = text.slice(0, -1);
+        }
+        if (text) {
+            this.push(Buffer.from(text, 'utf-8'));
+        }
+    }
+}
+/**
+ * Creates a Transform stream that decodes bytes in the given charset into UTF-8 Buffers. The
+ * charset name is resolved with normalizeCharset(), and the output is what decode() gives for
+ * the whole input, however it is split into chunks: the Japanese charsets iconv-lite does not
+ * support are decoded with encoding-japanese (collected until the input ends, as that decoder
+ * is not incremental), and an unknown or refused charset (UTF-7, base64, hex) is decoded as
+ * UTF-8 with `supported` set to false on the stream.
+ *
+ * @param [charset='UTF-8'] Charset the input is encoded in
+ * @return Transform stream with `charset` and `supported` properties
+ */
+export function createDecodeStream(charset) {
+    return new DecodeStream(charset);
+}
+export default { encode, decode, convert, normalizeCharset, createDecodeStream, DecodeStream };

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

@@ -111,6 +111,10 @@ const charsets = {
     mac: 'macintosh',
     macintosh: 'macintosh',
     'x-mac-roman': 'macintosh',
+    // the x-mac-* labels mail clients send, under the names iconv-lite knows them by
+    'x-mac-ce': 'maccenteuro',
+    'x-mac-cyrillic': 'maccyrillic',
+    'x-mac-ukrainian': 'macukraine',
     'dos-874': 'windows-874',
     'iso-8859-11': 'windows-874',
     'iso8859-11': 'windows-874',
@@ -178,7 +182,7 @@ const charsets = {
     'x-gbk': 'GBK',
     gb18030: 'gb18030',
     big5: 'Big5',
-    'big5-hkscs': 'Big5',
+    'big5-hkscs': 'Big5-HKSCS',
     'cn-big5': 'Big5',
     csbig5: 'Big5',
     'x-x-big5': 'Big5',
@@ -204,7 +208,9 @@ const charsets = {
     ksc_5601: 'EUC-KR',
     'windows-949': 'EUC-KR',
     'utf-16be': 'UTF-16BE',
-    'utf-16': 'UTF-16LE',
+    // iconv-lite's UTF-16 decoder reads the byte order from a BOM and guesses it from the
+    // content without one, falling back to little endian
+    'utf-16': 'UTF-16',
     'utf-16le': 'UTF-16LE'
 };
 export default charsets;

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

@@ -1,5 +1,6 @@
 import { Buffer } from 'node:buffer';
-import type { HeaderLine, HeaderObject, HeaderParam, LibmimeConfig, ParsedHeaderValue, StructuredHeaderValue } from './types.js';
+import * as libcharset from './charset.js';
+import type { DecodeHeadersOptions, HeaderLine, HeaderObject, HeaderParam, LibmimeConfig, ParsedHeaderValue, ParseHeaderValueOptions, StructuredHeaderValue } from './types.js';
 import type * as types from './types.js';
 export type * from './types.js';
 export declare class Libmime {
@@ -70,6 +71,16 @@ export declare class Libmime {
      * @return {String} Canonical charset name
      */
     normalizeCharset(charset?: unknown): string;
+    /**
+     * Creates a Transform stream that decodes a body in the given charset into UTF-8 Buffers,
+     * resolving the charset name and handling the Japanese charsets the same way header
+     * decoding does. An unknown or refused charset (UTF-7, base64, hex) is decoded as UTF-8,
+     * and the stream says so with `supported` set to false.
+     *
+     * @param {String} [charset='UTF-8'] Charset the input is encoded in
+     * @return {DecodeStream} Transform stream with `charset` and `supported` properties
+     */
+    createDecodeStream(charset?: unknown): libcharset.DecodeStream;
     /**
      * Decodes the inner payload of a single mime encoded-word into a unicode string.
      * Expects the three components of `=?charset?encoding?text?=` already separated.
@@ -112,9 +123,11 @@ export declare class Libmime {
      * header might have its own rules (eg. formatted email addresses and such)
      *
      * @param {String} headers Headers string
+     * @param {Object} [options] Options
+     * @param {Boolean} [options.skipPrototypeKeys] Leave out headers named like an Object.prototype member, eg. `__proto__` and `constructor`
      * @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;
+    decodeHeaders(headers: string, options?: DecodeHeadersOptions): 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.
@@ -140,9 +153,10 @@ export declare class Libmime {
      * decoded, so a caller that runs decodeWords() over the params has to leave them out
      *
      * @param {String} str Header value
+     * @param {Object} [options] Options, see ParseHeaderValueOptions
      * @return {Object} Header value as a parsed structure
      */
-    parseHeaderValue(str: string): ParsedHeaderValue;
+    parseHeaderValue(str: string, options?: ParseHeaderValueOptions): ParsedHeaderValue;
     /**
      * Encodes a string or an Buffer to an UTF-8 Parameter Value Continuation encoding (rfc2231)
      * Useful for splitting long parameter values.
@@ -207,12 +221,15 @@ declare const libmime: Libmime & {
 type LibmimeInstance = Libmime;
 declare namespace libmime {
     type Libmime = LibmimeInstance;
+    type DecodeStream = libcharset.DecodeStream;
+    type DecodeHeadersOptions = types.DecodeHeadersOptions;
     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 ParseHeaderValueOptions = types.ParseHeaderValueOptions;
     type StructuredHeader = types.StructuredHeader;
     type StructuredHeaderValue = types.StructuredHeaderValue;
 }