imapkit 4.0.3 → 4.1.0

package/{lib → dist/esm}/mailbox-name.js

@@ -1,8 +1,5 @@
-'use strict';
-
 // 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
@@ -16,51 +13,40 @@ 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) {
@@ -74,12 +60,10 @@ function checkBase64(encoded) {
             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) {
@@ -90,14 +74,13 @@ function checkBase64(encoded) {
                 return 'Invalid UTF-16 in mailbox name';
             }
             i++;
-        } else if (unit >= 0xdc00 && unit <= 0xdfff) {
+        }
+        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)
  *
@@ -112,7 +95,6 @@ function encodeMailboxName(name) {
         return '&' + Buffer.from(chunk, 'utf16le').swap16().toString('base64').replace(/=+$/, '').replace(/\//g, ',') + '-';
     });
 }
-
 /**
  * Decodes a modified UTF-7 mailbox name (RFC 3501 section 5.1.3)
  *
@@ -123,11 +105,8 @@ function decodeMailboxName(name) {
     if (validateMailboxName(name)) {
         return false;
     }
-    return name.replace(/&([^-]*)-/g, (match, encoded) => (encoded ? Buffer.from(encoded.replace(/,/g, '/'), 'base64').swap16().toString('utf16le') : '&'));
+    return name.replace(/&([^-]*)-/g, (match, encoded) => encoded ? Buffer.from(encoded.replace(/,/g, '/'), 'base64').swap16().toString('utf16le') : '&');
 }
-
-module.exports = validateMailboxName;
-module.exports.encode = encodeMailboxName;
-module.exports.decode = decodeMailboxName;
+export default validateMailboxName;
 // CATENATE resolves URL mailbox names with it
-module.exports.encodeMailboxName = encodeMailboxName;
+export { encodeMailboxName as encode, decodeMailboxName as decode, encodeMailboxName };

package/dist/esm/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 };