imapkit 4.0.3 → 4.1.0

package/dist/cjs/mailbox-name.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encodeMailboxName;
+exports.encodeMailboxName = encodeMailboxName;
+exports.decode = decodeMailboxName;
+// Modified BASE64 alphabet of RFC 3501 section 5.1.3 ("," instead of "/")
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,';
+/**
+ * Checks a mailbox name against the modified UTF-7 rules of RFC 3501 section 5.1.3:
+ * printable US-ASCII represents itself, "&" is written as "&-", everything else
+ * is encoded in modified BASE64 between "&" and "-", without superfluous shifts
+ * and without encoding printable US-ASCII.
+ *
+ * @param {String} name Mailbox name as a binary string
+ * @return {String|Boolean} Description of the problem, or false if the name is valid
+ */
+function validateMailboxName(name) {
+    if (typeof name !== 'string') {
+        return 'Invalid mailbox name';
+    }
+    let i = 0;
+    while (i < name.length) {
+        const code = name.charCodeAt(i);
+        if (code < 0x20 || code > 0x7e) {
+            return 'Mailbox name must use modified UTF-7 for non-ASCII characters (RFC 3501 section 5.1.3)';
+        }
+        if (name.charAt(i) !== '&') {
+            i++;
+            continue;
+        }
+        if (name.charAt(i + 1) === '-') {
+            // "&-" is the "&" character
+            i += 2;
+            continue;
+        }
+        const end = name.indexOf('-', i + 1);
+        if (end < 0) {
+            return 'Modified BASE64 in mailbox name must end with "-" (RFC 3501 section 5.1.3)';
+        }
+        const error = checkBase64(name.slice(i + 1, end));
+        if (error) {
+            return error;
+        }
+        if (name.charAt(end + 1) === '&' && name.charAt(end + 2) !== '-') {
+            return 'Mailbox name contains a superfluous shift (RFC 3501 section 5.1.3)';
+        }
+        i = end + 1;
+    }
+    return false;
+}
+function checkBase64(encoded) {
+    let bits = 0;
+    let bitCount = 0;
+    const units = [];
+    for (let i = 0; i < encoded.length; i++) {
+        const value = BASE64_CHARS.indexOf(encoded.charAt(i));
+        if (value < 0) {
+            return 'Invalid modified BASE64 in mailbox name (RFC 3501 section 5.1.3)';
+        }
+        bits = (bits << 6) | value;
+        bitCount += 6;
+        if (bitCount >= 16) {
+            bitCount -= 16;
+            units.push((bits >> bitCount) & 0xffff);
+            bits &= (1 << bitCount) - 1;
+        }
+    }
+    // leftover bits are padding and must be zero, and must not hold a partial character
+    if (!units.length || bitCount >= 6 || bits !== 0) {
+        return 'Invalid modified BASE64 in mailbox name (RFC 3501 section 5.1.3)';
+    }
+    for (let i = 0; i < units.length; i++) {
+        const unit = units[i];
+        if (unit >= 0x20 && unit <= 0x7e) {
+            return 'Modified BASE64 must not encode printable US-ASCII (RFC 3501 section 5.1.3)';
+        }
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            if (!(units[i + 1] >= 0xdc00 && units[i + 1] <= 0xdfff)) {
+                return 'Invalid UTF-16 in mailbox name';
+            }
+            i++;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff) {
+            return 'Invalid UTF-16 in mailbox name';
+        }
+    }
+    return false;
+}
+/**
+ * Encodes a mailbox name in modified UTF-7 (RFC 3501 section 5.1.3)
+ *
+ * @param {String} name Mailbox name as a unicode string
+ * @return {String} Modified UTF-7 name
+ */
+function encodeMailboxName(name) {
+    return name.replace(/&|[^\x20-\x7e]+/g, chunk => {
+        if (chunk === '&') {
+            return '&-';
+        }
+        return '&' + Buffer.from(chunk, 'utf16le').swap16().toString('base64').replace(/=+$/, '').replace(/\//g, ',') + '-';
+    });
+}
+/**
+ * Decodes a modified UTF-7 mailbox name (RFC 3501 section 5.1.3)
+ *
+ * @param {String} name Mailbox name as a binary string
+ * @return {String|Boolean} Mailbox name as a unicode string, or false if the name is not valid modified UTF-7
+ */
+function decodeMailboxName(name) {
+    if (validateMailboxName(name)) {
+        return false;
+    }
+    return name.replace(/&([^-]*)-/g, (match, encoded) => encoded ? Buffer.from(encoded.replace(/,/g, '/'), 'base64').swap16().toString('utf16le') : '&');
+}
+exports.default = validateMailboxName;
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/mimeparser.d.ts

@@ -0,0 +1,137 @@
+import type { ParsedAddress } from './addressparser.js';
+import type { Message } from './types.js';
+/** A structured header value (Content-Type, Content-Disposition) split into its parts */
+export interface StructuredValue {
+    /** the value without parameters, e.g. `text/plain` */
+    value: string;
+    /** lower case type, e.g. `text` */
+    type: string;
+    subtype: string;
+    /** parameters by lower case name, RFC 2231 continuations joined and decoded */
+    params: Record<string, string>;
+    /** set when the value had parameters */
+    hasParams?: boolean;
+}
+/**
+ * The parsed header of a node, keyed by lower case field name. Fields that occur more than once are kept as a
+ * list, except the ones listed in processNodeHeader(), where the last one wins
+ */
+export interface ParsedHeader {
+    /** always present, processNodeHeader() sets a default */
+    'content-type': StructuredValue;
+    'content-disposition'?: StructuredValue;
+    'content-transfer-encoding'?: string;
+    from?: ParsedAddress[];
+    sender?: ParsedAddress[];
+    'reply-to'?: ParsedAddress[];
+    to?: ParsedAddress[];
+    cc?: ParsedAddress[];
+    bcc?: ParsedAddress[];
+    [key: string]: any;
+}
+/** A node of the parsed MIME tree, see the grammar at the top of this file */
+export interface MimeNode {
+    /** header lines, a folded field joined into one line with its CRLF */
+    header: string[];
+    parsedHeader: ParsedHeader;
+    /** body octets (the preamble of a multipart) as a binary string */
+    body: string;
+    /** parts of a multipart, missing when there are none */
+    childNodes?: MimeNode[];
+    /** subtype of a multipart */
+    multipart: string | false;
+    boundary: string | false;
+    /** size of the body in octets */
+    size: number;
+    /** line breaks in the body */
+    lineCount: number;
+    /** false when the entity has no blank line and no body after its header */
+    hasBody?: boolean;
+    /** the input ended within the last header line */
+    headerUnterminated?: boolean;
+    /** a multipart without a close delimiter */
+    unterminated?: boolean;
+    /** a part that ends without the line break that belongs to the next delimiter */
+    bare?: boolean;
+    /** transport padding after the delimiter before this part */
+    pad?: string;
+    /** transport padding after the close delimiter */
+    closePad?: string;
+    epilogue?: string;
+    /** the parsed message of a message/rfc822 part */
+    message?: MimeNode;
+    /** the parsed message of a message/global part */
+    globalMessage?: MimeNode;
+}
+declare const IDENTITY_ENCODINGS: string[];
+/**
+ * Converts every line break of a message to CRLF. IMAP serves messages with CRLF line breaks, so sizes and
+ * contents are computed from this form
+ *
+ * @param {String} raw Message source as a binary string
+ * @return {String} Message source with CRLF line breaks
+ */
+declare function normalizeLineBreaks(raw: string | Buffer): string;
+/**
+ * Parses a message into a MIME tree
+ *
+ * @param {String} rfc822 Message source as a binary string with CRLF line breaks
+ * @param {Number} [depth] Nesting level of message/rfc822 parts
+ * @return {Object} Root node of the tree
+ */
+declare function parseTree(rfc822: string, depth?: number): MimeNode;
+/**
+ * The parts of a node as IMAP numbers them: the parts of a multipart (the placeholder when it has none),
+ * undefined for anything else
+ *
+ * @param {Object} node A tree node
+ * @returns {Array|undefined} Part nodes
+ */
+declare function partsOf(node: MimeNode): MimeNode[] | undefined;
+/**
+ * The message encapsulated in a node: the message of a message/rfc822 part, and with `global` also of a
+ * message/global part (RFC 9051 sections 6.4.5.1 and 7.5.2, IMAP4rev1 treats message/global as a basic part)
+ *
+ * @param {Object} node A tree node
+ * @param {Boolean} [global] Treat message/global like message/rfc822
+ * @returns {Object|undefined} Root node of the encapsulated message
+ */
+declare function embeddedMessage(node: MimeNode, global?: boolean): MimeNode | undefined;
+/**
+ * Resolves a numeric part path to a node. RFC 3501 6.4.5: the parts of a multipart are numbered from 1,
+ * a non-multipart message has one part which is the message itself, and the parts of a message/rfc822
+ * part are numbered under it
+ *
+ * @param {Object} tree Root node
+ * @param {String} path Dot-separated numeric path
+ * @param {Boolean} [global] Number the parts of message/global parts too, like IMAP4rev2 does
+ * @return {Object|Boolean} Node, or false when there is no such part
+ */
+declare function resolveNode(tree: MimeNode, path: string | number, global?: boolean): MimeNode | false;
+/**
+ * The header of a node as the HEADER and MIME sections return it, with the blank line that ends it
+ *
+ * @param {Object} node Tree node
+ * @return {String} Header section
+ */
+declare function headerSection(node: MimeNode): string;
+/**
+ * Renders a node of the tree back to the octets it was parsed from
+ *
+ * @param {Object} node Tree node
+ * @param {Boolean} [textOnly] Leave out the header of the node (BODY[TEXT], BODY[n])
+ * @return {String} Binary string
+ */
+declare function render(node: MimeNode, textOnly?: boolean): string;
+/**
+ * Returns the source with CRLF line breaks and the MIME tree of a message
+ *
+ * @param {Object} message Message object with a `raw` property
+ * @return {Object} `{ raw, tree }`
+ */
+declare function getMessageData(message: Message): {
+    raw: string;
+    tree: MimeNode;
+};
+export default function mimeparser(rfc822: string): MimeNode;
+export { parseTree, IDENTITY_ENCODINGS, getMessageData, normalizeLineBreaks, partsOf, resolveNode, embeddedMessage, headerSection, render };