imapkit 4.0.3 → 4.1.1

package/{lib → dist/esm}/mimeparser.js

@@ -1,5 +1,3 @@
-'use strict';
-
 // Parses a message into a MIME tree. Ported from WildDuck (imap-core/lib/indexer/parse-mime-tree.js and
 // tree-walker.js), adapted to ImapKit, where message sources are binary strings (one char per octet).
 //
@@ -11,19 +9,14 @@
 //
 // The CRLF after an entity belongs to the delimiter that follows it (RFC 2046 5.1.1), a part body never
 // includes it.
-
-const addressparser = require('./addressparser');
-
+import addressparser from './addressparser.js';
 // header field and parameter names that are kept in the parsed header, anything else is only available
 // through the raw header lines
 const FIELD_NAME = /^[a-zA-Z0-9\-*]{1,99}$/;
-
 // content transfer encodings that leave the data as it is (RFC 2045 section 6.2)
 const IDENTITY_ENCODINGS = ['7bit', '8bit', 'binary'];
-
 // message/rfc822 parts nested deeper than this are not parsed, they are described as plain parts
 const MAX_MESSAGE_DEPTH = 32;
-
 /**
  * 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
@@ -32,11 +25,10 @@ const MAX_MESSAGE_DEPTH = 32;
  * @return {String} Message source with CRLF line breaks
  */
 function normalizeLineBreaks(raw) {
-    const str = (raw || '').toString('binary');
+    const str = Buffer.isBuffer(raw) ? raw.toString('binary') : raw || '';
     // most messages already use CRLF, so only replace if there is a bare LF
     return /(?:^|[^\r])\n/.test(str) ? str.replace(/\r?\n/g, '\r\n') : str;
 }
-
 /**
  * Splits a structured header value (RFC 2045 5.1 Content-Type and friends) at a separator character,
  * leaving quoted strings intact and dropping RFC 822 comments outside of them. With no separator the
@@ -51,50 +43,50 @@ function splitStructuredValue(value, separator) {
     let current = '';
     let quoted = false;
     let depth = 0;
-
     for (let i = 0; i < value.length; i++) {
         const chr = value.charAt(i);
-
         if (quoted) {
             current += chr;
             if (chr === '\\' && i + 1 < value.length) {
                 // quoted-pair, keep the escaped character for the value parser
                 current += value.charAt(++i);
-            } else if (chr === '"') {
+            }
+            else if (chr === '"') {
                 quoted = false;
             }
             continue;
         }
-
         if (depth) {
             // inside a comment, which may nest and may hold quoted-pairs
             if (chr === '\\') {
                 i++;
-            } else if (chr === '(') {
+            }
+            else if (chr === '(') {
                 depth++;
-            } else if (chr === ')') {
+            }
+            else if (chr === ')') {
                 depth--;
             }
             continue;
         }
-
         if (chr === '"') {
             quoted = true;
             current += chr;
-        } else if (chr === '(') {
+        }
+        else if (chr === '(') {
             depth = 1;
-        } else if (separator && chr === separator) {
+        }
+        else if (separator && chr === separator) {
             parts.push(current);
             current = '';
-        } else {
+        }
+        else {
             current += chr;
         }
     }
-
     parts.push(current);
     return parts;
 }
-
 /**
  * Decodes an RFC 2231 extended parameter value (percent encoded octets in a charset). UTF-8 and US-ASCII
  * values become the UTF-8 octets, ISO-8859-1 values are converted to UTF-8, other charsets are kept as
@@ -121,7 +113,6 @@ function decodeExtendedValue(charset, value) {
             return '=?' + charset.toUpperCase() + '?Q?' + value.replace(/%/g, '=') + '?=';
     }
 }
-
 class MIMEParser {
     /**
      * @param {String} rfc822 Message source as a binary string with CRLF line breaks
@@ -130,48 +121,43 @@ class MIMEParser {
     constructor(rfc822, depth) {
         this.rfc822 = rfc822 || '';
         this.depth = depth || 0;
-
         // the line break that ended the last line read, false once the input is used up
         this._br = '';
         this._pos = 0;
-
         this.tree = {
             childNodes: []
         };
         this._node = this.createNode(this.tree);
     }
-
     /**
      * Parses the message, line by line
      */
     parse() {
         let line;
         let prevBr = '';
-
         // keep parsing until the last linebreak is not a string (no linebreaks anymore)
         while (typeof this._br === 'string') {
             line = this.readLine();
-
             const delimiter = this.matchDelimiter(line);
             if (delimiter) {
                 this.endPart(delimiter, prevBr);
-            } else {
+            }
+            else {
                 switch (this._node.state) {
                     case 'header':
                         if (!line) {
                             // the blank line that separates the header from the body
                             this.endHeader();
-                        } else {
+                        }
+                        else {
                             this._node.header.push(line);
                         }
                         break;
-
                     case 'body':
                         // push the line with previous linebreak value, joined together the lines
                         // give the original body
                         this._node.body.push((this._node.body.length ? prevBr : '') + line);
                         break;
-
                     case 'epilogue':
                         // RFC 2046 5.1.1: everything after the close delimiter up to the next delimiter
                         // of the enclosing multipart (or the end of the message) is the epilogue. Every
@@ -182,18 +168,15 @@ class MIMEParser {
                         }
                         this._node.epilogue.push(prevBr + line);
                         break;
-
                     default:
                         // never should be reached
                         throw new Error('Unexpected state');
                 }
             }
-
             // store the linebreak for later usage
             prevBr = this._br;
         }
     }
-
     /**
      * Reads a line from the message
      *
@@ -208,18 +191,15 @@ class MIMEParser {
             this._br = false;
             return line;
         }
-
         let lineEnd = end;
         if (lineEnd > this._pos && this.rfc822.charCodeAt(lineEnd - 1) === 0x0d) {
             lineEnd--;
         }
-
         const line = this.rfc822.slice(this._pos, lineEnd);
         this._br = this.rfc822.slice(lineEnd, end + 1);
         this._pos = end + 1;
         return line;
     }
-
     /**
      * Ends the header of the current node: its blank line was read, or a delimiter took its place
      */
@@ -228,7 +208,6 @@ class MIMEParser {
         this.processContentType();
         this._node.state = 'body';
     }
-
     /**
      * Checks whether a line is a delimiter of an open multipart: the current node while it collects its
      * preamble or epilogue, the multipart the current node belongs to, or any multipart above that (a
@@ -244,7 +223,6 @@ class MIMEParser {
         if (!line.startsWith('--')) {
             return false;
         }
-
         const node = this._node;
         // a boundary is only known once the header has ended
         const innermost = node.boundary ? node : node.parentNode;
@@ -253,28 +231,22 @@ class MIMEParser {
             if (!line.startsWith(delimiter)) {
                 continue;
             }
-
             let rest = line.slice(delimiter.length);
             const close = rest.startsWith('--');
             if (close) {
                 rest = rest.slice(2);
             }
-
             if (/[^ \t]/.test(rest)) {
                 // something other than padding after the boundary, so a different boundary or text
                 continue;
             }
-
             if (multipart.state === 'epilogue') {
                 return false;
             }
-
             return { multipart, close, pad: rest };
         }
-
         return false;
     }
-
     /**
      * Ends whatever the current node was collecting at a delimiter line and moves on to the next
      * part of that multipart, or to its epilogue
@@ -285,7 +257,6 @@ class MIMEParser {
     endPart(delimiter, prevBr) {
         const node = this._node;
         const multipart = delimiter.multipart;
-
         if (node !== multipart) {
             // a part ends here
             if (node.state === 'header') {
@@ -299,19 +270,20 @@ class MIMEParser {
                     open.bare = true;
                 }
             }
-        } else if (node.body.length) {
+        }
+        else if (node.body.length) {
             // the preamble ends here. The line break between the preamble and the delimiter belongs to
             // the delimiter, but the preamble lines end with their own
             node.body[node.body.length - 1] += prevBr;
         }
-
         if (!delimiter.close) {
             const next = this.createNode(multipart);
             if (delimiter.pad) {
                 next.pad = delimiter.pad;
             }
             this._node = next;
-        } else {
+        }
+        else {
             if (delimiter.pad) {
                 multipart.closePad = delimiter.pad;
             }
@@ -320,7 +292,6 @@ class MIMEParser {
             this._node = multipart;
         }
     }
-
     /**
      * Parses the body of a message/rfc822 node into `node.message`. RFC 2046 5.2.1 only allows the
      * identity encodings for such a body, RFC 2045 5.1 and 6.1 make the type and encoding names case
@@ -339,7 +310,6 @@ class MIMEParser {
         }
         node[type === 'message/rfc822' ? 'message' : 'globalMessage'] = parseTree(node.body, this.depth + 1);
     }
-
     /**
      * Joins body arrays into strings. Removes unnecessary fields from the tree
      */
@@ -351,43 +321,38 @@ class MIMEParser {
                 this._node.headerUnterminated = true;
             }
         }
-
         // iterative, so that deeply nested multiparts do not exhaust the stack
-        const stack = [].concat(this.tree.childNodes);
+        const stack = [...this.tree.childNodes];
         while (stack.length) {
-            const node = stack.pop();
-
+            const parsing = stack.pop();
+            // the same object, from here on with its lines joined
+            const node = parsing;
+            const lines = parsing.body;
             // a body section holds lines, parts, or at least a close delimiter. A blank line followed by
             // the end of the input leaves the trailing empty line in the body, one followed directly by
             // a delimiter leaves nothing
             const closed = node.boundary && !node.unterminated;
-            if (!(node.body.length || node.childNodes.length || closed)) {
+            if (!(lines.length || parsing.childNodes.length || closed)) {
                 node.hasBody = false;
             }
-
             // RFC 3501 7.4.2 body-fld-lines, counted like Dovecot does: the line breaks in the body
-            node.lineCount = node.body.length ? node.body.length - 1 : 0;
-            node.body = node.body.join('');
+            node.lineCount = lines.length ? lines.length - 1 : 0;
+            node.body = lines.join('');
             node.size = node.body.length;
-
             // a message/rfc822 entity carries its parsed message
             this.parseEmbeddedMessage(node);
-
-            if (node.epilogue) {
-                node.epilogue = node.epilogue.join('');
+            if (parsing.epilogue) {
+                node.epilogue = parsing.epilogue.join('');
             }
-
-            node.childNodes.forEach(child => stack.push(child));
-
+            parsing.childNodes.forEach(child => stack.push(child));
             // remove unneeded properties
-            delete node.parentNode;
-            delete node.state;
+            delete parsing.parentNode;
+            delete parsing.state;
             if (!node.childNodes.length) {
                 delete node.childNodes;
             }
         }
     }
-
     /**
      * Creates a new node with default values for the parse tree
      */
@@ -405,61 +370,58 @@ class MIMEParser {
         parentNode.childNodes.push(node);
         return node;
     }
-
     /**
      * Processes header lines. Splits lines to key-value pairs
      * and processes special values
      */
     processNodeHeader() {
         const node = this._node;
-
+        // the fields hold raw values until they are parsed below
+        const fields = node.parsedHeader;
         // RFC 5322 2.2.3: a line that starts with whitespace continues the previous header field
         const header = [];
         for (const line of node.header) {
             if (header.length && /^\s/.test(line)) {
                 header[header.length - 1] += '\r\n' + line;
-            } else {
+            }
+            else {
                 header.push(line);
             }
         }
         node.header = header;
-
         for (const line of header) {
-            let value = line.split(':');
-            const key = (value.shift() || '').trim().toLowerCase();
-            value = value.join(':').trim();
-
+            const parts = line.split(':');
+            const key = (parts.shift() || '').trim().toLowerCase();
+            const value = parts.join(':').trim();
             // Do not touch headers that have strange looking keys, keep these
             // only in the unparsed array
             if (!FIELD_NAME.test(key)) {
                 continue;
             }
-
-            if (key in node.parsedHeader) {
-                if (Array.isArray(node.parsedHeader[key])) {
-                    node.parsedHeader[key].push(value);
-                } else {
-                    node.parsedHeader[key] = [node.parsedHeader[key], value];
+            if (key in fields) {
+                if (Array.isArray(fields[key])) {
+                    fields[key].push(value);
                 }
-            } else {
-                node.parsedHeader[key] = value.replace(/\s*\r?\n\s*/g, ' ');
+                else {
+                    fields[key] = [fields[key], value];
+                }
+            }
+            else {
+                fields[key] = value.replace(/\s*\r?\n\s*/g, ' ');
             }
         }
-
         // always ensure the presence of Content-Type. RFC 2046 5.1.5: inside a digest the default
         // is message/rfc822 instead of text/plain
-        if (!node.parsedHeader['content-type']) {
+        if (!fields['content-type']) {
             const parentSubtype = ((node.parentNode && node.parentNode.multipart) || '').toString().toLowerCase();
-            node.parsedHeader['content-type'] = parentSubtype === 'digest' ? 'message/rfc822' : 'text/plain';
+            fields['content-type'] = parentSubtype === 'digest' ? 'message/rfc822' : 'text/plain';
         }
-
         // parse additional params for Content-Type and Content-Disposition, the last header wins
         ['content-type', 'content-disposition'].forEach(key => {
-            if (node.parsedHeader[key]) {
-                node.parsedHeader[key] = this.parseValueParams([].concat(node.parsedHeader[key]).pop());
+            if (fields[key]) {
+                fields[key] = this.parseValueParams([].concat(fields[key]).pop());
             }
         });
-
         // ensure single value for selected fields, the last header wins
         [
             'subject',
@@ -473,24 +435,21 @@ class MIMEParser {
             'content-md5',
             'content-location'
         ].forEach(key => {
-            if (Array.isArray(node.parsedHeader[key])) {
-                node.parsedHeader[key] = node.parsedHeader[key].pop().replace(/\s*\r?\n\s*/g, ' ');
+            if (Array.isArray(fields[key])) {
+                fields[key] = fields[key].pop().replace(/\s*\r?\n\s*/g, ' ');
             }
         });
-
-        if (node.parsedHeader['content-transfer-encoding']) {
+        if (fields['content-transfer-encoding']) {
             // RFC 2045 6.1: the mechanism token may be followed by a comment, which is not part of it
-            node.parsedHeader['content-transfer-encoding'] = splitStructuredValue(node.parsedHeader['content-transfer-encoding'])[0].trim();
+            fields['content-transfer-encoding'] = splitStructuredValue(fields['content-transfer-encoding'])[0].trim();
         }
-
         // Parse address fields (join several fields with same key)
         ['from', 'sender', 'reply-to', 'to', 'cc', 'bcc'].forEach(key => {
-            if (node.parsedHeader[key]) {
-                node.parsedHeader[key] = [].concat(node.parsedHeader[key]).flatMap(value => (value && addressparser(value.replace(/\s*\r?\n\s*/g, ' '))) || []);
+            if (fields[key]) {
+                fields[key] = [].concat(fields[key]).flatMap(value => (value && addressparser(value.replace(/\s*\r?\n\s*/g, ' '))) || []);
             }
         });
     }
-
     /**
      * Splits a value to an object.
      * eg. 'text/plain; charset=utf-8' -> {value: 'text/plain', params:{charset: 'utf-8'}}
@@ -505,10 +464,8 @@ class MIMEParser {
             subtype: '',
             params: Object.create(null)
         };
-
         // RFC 2231 continuations and extended values, by parameter name
         const continuations = Object.create(null);
-
         splitStructuredValue(headerValue || '', ';').forEach((part, i) => {
             if (!i) {
                 data.value = part.trim();
@@ -517,23 +474,21 @@ class MIMEParser {
                 data.subtype = subtype.join('/');
                 return;
             }
-
-            let value = part.split('=');
-            const key = (value.shift() || '').trim().toLowerCase();
-            value = value.join('=').trim();
+            const parts = part.split('=');
+            const key = (parts.shift() || '').trim().toLowerCase();
+            let value = parts.join('=').trim();
             if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
                 // RFC 2045 5.1 quoted-string: the quotes are not part of the value and a backslash
                 // quotes the character after it (RFC 822 3.3)
                 value = value.slice(1, -1).replace(/\\([\s\S])/g, '$1');
-            } else {
+            }
+            else {
                 value = value.replace(/^['"\s]*|['"\s]*$/g, '');
             }
-
             // Do not touch parameters that have strange looking keys
             if (!FIELD_NAME.test(key)) {
                 return;
             }
-
             // RFC 2231 3 and 4: `name*N` is segment N of a continued value, a trailing asterisk marks
             // a segment as extended (percent encoded, the first one prefixed with charset'language')
             const match = key.match(/^([^*]+)(?:\*(\d{1,3}))?(\*)?$/);
@@ -543,17 +498,16 @@ class MIMEParser {
                     continuations[name] = [];
                 }
                 continuations[name][Number(match[2]) || 0] = { value, extended: !!match[3] };
-            } else {
+            }
+            else {
                 data.params[key] = value;
             }
             data.hasParams = true;
         });
-
         Object.keys(continuations).forEach(key => {
             let charset = '';
             let encoded = '';
             let extended = false;
-
             continuations[key].forEach((segment, i) => {
                 if (!segment) {
                     return;
@@ -570,18 +524,16 @@ class MIMEParser {
                 if (segment.extended) {
                     extended = true;
                     encoded += value;
-                } else {
+                }
+                else {
                     // a segment that is not extended is plain text, encode it like the rest
                     encoded += value.replace(/[^\x21-\x24\x26-\x7e]/g, chr => '%' + ('0' + chr.charCodeAt(0).toString(16)).substr(-2));
                 }
             });
-
             data.params[key] = extended ? decodeExtendedValue(charset, encoded) : decodeExtendedValue('', encoded);
         });
-
         return data;
     }
-
     /**
      * Checks Content-Type value for the current tree node.
      */
@@ -589,7 +541,6 @@ class MIMEParser {
         const node = this._node;
         // processNodeHeader() always sets a Content-Type
         const contentType = node.parsedHeader['content-type'];
-
         if (contentType.type === 'multipart' && contentType.params.boundary) {
             node.multipart = contentType.subtype;
             node.boundary = contentType.params.boundary;
@@ -598,7 +549,6 @@ class MIMEParser {
         }
     }
 }
-
 /**
  * Parses a message into a MIME tree
  *
@@ -610,13 +560,12 @@ function parseTree(rfc822, depth) {
     const parser = new MIMEParser(rfc822, depth);
     parser.parse();
     parser.finalizeTree();
+    // finalizeTree() turned the nodes into MimeNodes
     return parser.tree.childNodes[0];
 }
-
 // RFC 3501 9: body-type-mpart = 1*body SP media-subtype. A multipart whose boundary never appeared has
 // no parts, so this empty text part stands in for them
 const PLACEHOLDER_PART = parseTree('Content-Type: text/plain\r\n\r\n');
-
 /**
  * The parts of a node as IMAP numbers them: the parts of a multipart (the placeholder when it has none),
  * undefined for anything else
@@ -630,7 +579,6 @@ function partsOf(node) {
     }
     return node.boundary ? [PLACEHOLDER_PART] : 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)
@@ -642,7 +590,6 @@ function partsOf(node) {
 function embeddedMessage(node, global) {
     return node.message || (global ? node.globalMessage : 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
@@ -657,25 +604,20 @@ function resolveNode(tree, path, global) {
     // the message whose parts the next number counts
     let scope = tree;
     let node = tree;
-
     for (const number of (path || '').toString().split('.')) {
         const index = Number(number) - 1;
         if (!scope || !(index >= 0)) {
             return false;
         }
-
         const parts = partsOf(scope);
         node = parts ? parts[index] : index === 0 ? scope : undefined;
         if (!node) {
             return false;
         }
-
         scope = embeddedMessage(node, global) || (partsOf(node) ? node : false);
     }
-
     return node;
 }
-
 /**
  * The header of a node as the HEADER and MIME sections return it, with the blank line that ends it
  *
@@ -690,7 +632,6 @@ function headerSection(node) {
     }
     return header.length ? header.join('\r\n') + '\r\n\r\n' : '\r\n';
 }
-
 /**
  * Renders a node of the tree back to the octets it was parsed from
  *
@@ -700,7 +641,6 @@ function headerSection(node) {
  */
 function render(node, textOnly) {
     const output = [];
-
     const walk = (node, withHeader) => {
         if (withHeader) {
             const header = node.header || [];
@@ -708,22 +648,17 @@ function render(node, textOnly) {
                 output.push(header.join('\r\n') + (node.headerUnterminated ? '' : '\r\n'));
             }
         }
-
         if (node.hasBody === false) {
             return;
         }
-
         if (withHeader) {
             // the blank line between header and body
             output.push('\r\n');
         }
-
         output.push(node.body || '');
-
         if (!node.boundary) {
             return;
         }
-
         const children = node.childNodes || [];
         for (let i = 0; i < children.length; i++) {
             const child = children[i];
@@ -734,20 +669,16 @@ function render(node, textOnly) {
                 output.push('\r\n');
             }
         }
-
         if (!node.unterminated) {
             output.push('--' + node.boundary + '--' + (node.closePad || ''));
             output.push(node.epilogue || '');
         }
     };
-
     walk(node, !textOnly);
     return output.join('');
 }
-
 // Parsed data of messages, so a message is parsed only once and not again until its source changes
 const cache = new WeakMap();
-
 /**
  * Returns the source with CRLF line breaks and the MIME tree of a message
  *
@@ -763,16 +694,7 @@ function getMessageData(message) {
     }
     return cached;
 }
-
-module.exports = function (rfc822) {
+export default function mimeparser(rfc822) {
     return parseTree(normalizeLineBreaks(rfc822));
-};
-module.exports.parseTree = parseTree;
-module.exports.IDENTITY_ENCODINGS = IDENTITY_ENCODINGS;
-module.exports.getMessageData = getMessageData;
-module.exports.normalizeLineBreaks = normalizeLineBreaks;
-module.exports.partsOf = partsOf;
-module.exports.resolveNode = resolveNode;
-module.exports.embeddedMessage = embeddedMessage;
-module.exports.headerSection = headerSection;
-module.exports.render = render;
+}
+export { parseTree, IDENTITY_ENCODINGS, getMessageData, normalizeLineBreaks, partsOf, resolveNode, embeddedMessage, headerSection, render };