imapkit 4.0.2 → 4.1.0

package/dist/esm/arguments.js

@@ -0,0 +1,96 @@
+// Checks of parsed command arguments (imap-handler parser output)
+/**
+ * Checks if a parsed argument is an atom, optionally a specific one
+ *
+ * @param {Object} value Parsed argument
+ * @param {String} [name] Upper case atom to match, the value is compared case-insensitively
+ * @return {Boolean} true for an atom (with that name)
+ */
+function isAtom(value, name) {
+    return !!value && !Array.isArray(value) && value.type === 'ATOM' && (name === undefined || String(value.value).toUpperCase() === name);
+}
+/**
+ * Checks if a parsed argument is an astring (RFC 3501 section 9): an atom, a quoted string or a literal. An
+ * atom the parser split into a section or partial range (like BODY[1]<0.5>) is not
+ *
+ * @param {Object} value Parsed argument
+ * @return {Boolean} true for an astring
+ */
+function isAstring(value) {
+    return !!value && !Array.isArray(value) && ['ATOM', 'STRING', 'LITERAL'].indexOf(value.type) >= 0 && !value.section && !value.partial;
+}
+// characters that end an atom in a command line (RFC 3501 section 9 atom-specials, and "[" "]" of sections)
+const ATOM_END = /[\s()[\]{"%*\\<]/;
+/**
+ * Lists how the client spelled the NIL atoms of a command line, in order. Quoted strings and literals are skipped
+ *
+ * @param {String} data Raw command line with its literals
+ * @return {Array} spellings, e.g. ["nil", "NIL"]
+ */
+function nilSpellings(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        const ch = data.charAt(i);
+        if (ch === '"') {
+            for (i++; i < data.length && data.charAt(i) !== '"'; i++) {
+                if (data.charAt(i) === '\\') {
+                    i++;
+                }
+            }
+            i++;
+            continue;
+        }
+        const literal = (ch === '{' || ch === '~') && data.substr(i, 32).match(/^~?\{(\d+)\+?\}\r\n/);
+        if (literal) {
+            i += literal[0].length + Number(literal[1]);
+            continue;
+        }
+        if (ATOM_END.test(ch)) {
+            i++;
+            continue;
+        }
+        let end = i;
+        while (end < data.length && !ATOM_END.test(data.charAt(end))) {
+            end++;
+        }
+        const token = data.substring(i, end);
+        if (/^nil$/i.test(token)) {
+            result.push(token);
+        }
+        i = end;
+    }
+    return result;
+}
+function restoreNilAtoms(parsed, data, select) {
+    if (!parsed.attributes || !/nil/i.test(data || '')) {
+        return;
+    }
+    // every null in the order the parser met them, sections included
+    const nulls = [];
+    const walk = (list, path) => {
+        list.forEach((item, i) => {
+            if (item === null) {
+                nulls.push({ list, index: i, path: path.concat(i) });
+            }
+            else if (Array.isArray(item)) {
+                walk(item, path.concat(i));
+            }
+            else if (item && Array.isArray(item.section)) {
+                walk(item.section, path.concat(i, 'section'));
+            }
+        });
+    };
+    walk(parsed.attributes, []);
+    if (!nulls.length) {
+        return;
+    }
+    // the tag and the command name come first, so the arguments are the last NIL atoms of the line
+    const spellings = nilSpellings(data).slice(-nulls.length);
+    nulls.forEach((entry, i) => {
+        if (select(entry.path)) {
+            entry.list[entry.index] = { type: 'ATOM', value: spellings.length === nulls.length ? spellings[i] : 'NIL' };
+        }
+    });
+}
+export { isAtom, isAstring, restoreNilAtoms };

package/dist/esm/bodystructure.d.ts

@@ -0,0 +1,25 @@
+import type { MimeNode } from './mimeparser.js';
+import type { Attribute } from './types.js';
+/** Options of createBodystructure() */
+export interface BodystructureOptions {
+    upperCaseKeys?: boolean | undefined;
+    skipContentLocation?: boolean | undefined;
+    body?: boolean | undefined;
+    messageGlobal?: boolean | undefined;
+}
+/** A BODY or BODYSTRUCTURE list, nested lists for the parts, compiled by imap-handler */
+export type Bodystructure = Attribute[];
+export default createBodystructure;
+/**
+ * Generates an object out of parsed mime tree, that can be
+ * serialized into a BODYSTRUCTURE string
+ *
+ * @param {Object} tree Parsed mime tree (see mimeparser.ts for input)
+ * @param {Object} [options] Optional options object
+ * @param {Boolean} [options.upperCaseKeys] If true, use only upper case key names
+ * @param {Boolean} [options.skipContentLocation] If true, do not include Content-Location in the output
+ * @param {Boolean} [options.body] If true, skip extension fields (needed for BODY)
+ * @param {Boolean} [options.messageGlobal] If true, describe message/global like message/rfc822 (IMAP4rev2, RFC 9051 section 7.5.2)
+ * @return {Array} Object structure in the form of BODYSTRUCTURE
+ */
+declare function createBodystructure(tree: MimeNode, options?: BodystructureOptions | null): Bodystructure;

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

@@ -1,19 +1,14 @@
-'use strict';
-
 // Converts a parsed MIME tree into BODY and BODYSTRUCTURE data. Ported from WildDuck
 // (imap-core/lib/indexer/body-structure.js)
-
-const envelope = require('./envelope');
-const { partsOf, embeddedMessage } = require('./mimeparser');
-
+import envelope from './envelope.js';
+import { partsOf, embeddedMessage } from './mimeparser.js';
 // Expose to the world
-module.exports = createBodystructure;
-
+export default createBodystructure;
 /**
  * Generates an object out of parsed mime tree, that can be
  * serialized into a BODYSTRUCTURE string
  *
- * @param {Object} tree Parsed mime tree (see mimeparser.js for input)
+ * @param {Object} tree Parsed mime tree (see mimeparser.ts for input)
  * @param {Object} [options] Optional options object
  * @param {Boolean} [options.upperCaseKeys] If true, use only upper case key names
  * @param {Boolean} [options.skipContentLocation] If true, do not include Content-Location in the output
@@ -23,37 +18,35 @@ module.exports = createBodystructure;
  */
 function createBodystructure(tree, options) {
     options = options || {};
-
-    const key = name => (options.upperCaseKeys && typeof name === 'string' ? name.toUpperCase() : name);
-
+    const key = (name) => (options.upperCaseKeys && typeof name === 'string' ? name.toUpperCase() : name);
     // Parameter list of a parsed structured header value, as the flat `(key value key value)` list
-    const paramList = parsed => {
+    const paramList = (parsed) => {
         if (!parsed || !parsed.hasParams) {
             return null;
         }
         const list = [];
-        Object.keys(parsed.params).forEach(name => {
-            list.push(key(name), parsed.params[name]);
+        // hasParams is only set together with params
+        const params = parsed.params;
+        Object.keys(params).forEach(name => {
+            list.push(key(name), params[name]);
         });
         return list.length ? list : null;
     };
-
-    const getBasicFields = node => {
+    const getBasicFields = (node) => {
         const contentType = node.parsedHeader['content-type'] || {};
         let bodyType = contentType.type || null;
         let bodySubtype = contentType.subtype || null;
-
         if (!bodyType || !bodySubtype) {
             // prevent strange content types like (NIL "/ms-word") that may break some clients
             if (bodyType === 'text' || bodySubtype === 'plain') {
                 bodyType = 'text';
                 bodySubtype = 'plain';
-            } else {
+            }
+            else {
                 bodyType = 'application';
                 bodySubtype = 'octet-stream';
             }
         }
-
         return [
             key(bodyType),
             key(bodySubtype),
@@ -69,20 +62,17 @@ function createBodystructure(tree, options) {
             node.size
         ];
     };
-
     // The extension fields every part has (a non-multipart part also has an MD5 before them)
-    const getExtensionFields = node => {
+    const getExtensionFields = (node) => {
         const languageString = node.parsedHeader['content-language'] && node.parsedHeader['content-language'].replace(/[ ,]+/g, ',').replace(/^,+|,+$/g, '');
         const language = (languageString && languageString.split(',')) || null;
         const disposition = node.parsedHeader['content-disposition'];
-
         const data = [
             // body disposition
             (disposition && [key(disposition.value), paramList(disposition)]) || null,
             // body language
             language
         ];
-
         // NB! RFC3501 has an errata with content-location type, it is described as
         // "A string list" (eg. an array) in RFC but the errata page states
         // that it is a string (http://www.rfc-editor.org/errata_search.php?rfc=3501)
@@ -90,10 +80,8 @@ function createBodystructure(tree, options) {
         if (!options.skipContentLocation) {
             data.push(node.parsedHeader['content-location'] || null);
         }
-
         return data;
     };
-
     // A non-multipart node: the basic fields, the fields of its type (line count for text, envelope and
     // structure for message/rfc822), and the extension fields unless BODY was asked for
     const processLeaf = (node, extra) => {
@@ -103,24 +91,21 @@ function createBodystructure(tree, options) {
         }
         return data;
     };
-
-    const processMultipartNode = node => {
+    const processMultipartNode = (node) => {
+        // only called for a node with parts
         let data = partsOf(node)
             .map(walker)
             .concat([key(node.multipart)]);
-
         if (!options.body) {
             // RFC 3501 7.4.2: BODY is BODYSTRUCTURE without extension data, and for a multipart the
             // parameter list is the first extension field (body-ext-mpart)
             data = data.concat([paramList(node.parsedHeader['content-type'])], getExtensionFields(node));
         }
-
         // body-type-mpart = 1*body SP media-subtype, there is no SP between the bodies (RFC 3501 section 9)
         Object.defineProperty(data, 'adjacentLists', { value: true });
         return data;
     };
-
-    const walker = node => {
+    const walker = (node) => {
         const contentType = node.parsedHeader['content-type'] || {};
         switch (contentType.type) {
             case 'multipart':
@@ -144,6 +129,5 @@ function createBodystructure(tree, options) {
                 return processLeaf(node, []);
         }
     };
-
     return walker(tree);
 }

package/dist/esm/cert.d.ts

@@ -0,0 +1,2 @@
+export declare const key = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDN0THQ8qpf3mMo\nNlVzVvjfsw/QHo22ojmmUO+3QjZDeB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQV\ncqRTDFkk9zBnCagFIWCi2DI4VgArzWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leK\njvSW2021Ntp8VX+KV5nXM3rRUWaPUSGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBP\nTPt9BNVO0CXL8zsiQfNOveN4nTBmF4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5O\nnPERgwZhgIg15G7Y/vz9N0vZGmIU7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44D\nG7hvX8DVAgMBAAECggEABIVNSlEiM+PfGrGC0/s7kTJOLRyWsUXD7WbGtShDp9y6\nFQXaaIxNP1FoJyqHP/p5fHsBO310waK/gYcYm+hgBuNVEVZRdfdjN4B3LeyZqVyk\nLbbNwfRferwIswydLBsy4cpwdLQAflI15Qm5zpx3ivzu9J8uI3xEGUl8r59RmOE9\ntXb+sA9YtWRXUR4mhqApGxMI5ZP1/WbmhlDvLUnartyBNilfS3RTWY7nWMKk3U0N\nyFmYX17WZYnXbJtXQmOX/LHd1nM2NFS2B6yJ6JKY0/jPOGCaTBcVmFgO3x/aDgiJ\nm0XL1mpGBIUugQTio5N1Ewznrg6SA7rzsOzN1g3ZqwKBgQD48+lGyQmFAaaXzf+9\nWiG6F6hQtsiWDwhQ3C1m1fOMk2Fgi/eVPEWxIRbf18XBwgvt4Q7PoyojzR730YZl\n5WsEpliGyaBdrR4ZRh92t3y0fQ6Q/AMhsIEIu62lZbLlLenW5/OZLyVsuctAUZCg\nHBNgwR1wuvBBXrc+TIXjUYgsfwKBgQDTpLEqsjh8ZrCvubH0mlTCHkSS/A3ifk27\nsuLZhps0J0JMM1drxpNHcfySZ31sVrMZog1cf5W6z55pYlEDCrlEjK2gjyzJnmUA\nKE+ramKMH1/hfxdVZLY1F1zL2oLuprQEE6AUMDdZiv4JMcNfHA05Ii5VpsGe/sVe\naCiudjH4qwKBgFEFiMk5ynhYJjDHoVCt0cYvxt6l7jgwIkO2tKwAO6hnmsyCIQyX\nthLEsx4cqka58Yn0sg5Pivpl2otKzJPDC4ZS4QLVAfUaz23oTXskklhnTuNOsXI4\ncHY4JnZq18MQo0cG7FfRaTuuaADByvDg0kmt7/ftTx3nRnnnC7gEo+3fAoGAX4WG\nfNnBSsxiVH2ARwDc3lwg4SIn9iDBXsTnQ/xP0mMhthi6DSer02Qr9bwFzL74yMnu\nM+BVqOIKAlBgdfoCEmFYAA5+zWTS+xY2lwxF/C4w7SqaUm1JG3823774t1PADdL5\nvgLhCGYGMAoovqV/hljaBshjvSoJ1Ik4Sz2HYk8CgYEAnSqiwlpYZKQX7jBo7yWA\nxB6r81uUHwy+XOq7A4OfgbEEuuKQ6tXOg72FX+38rF+Td6iA+6qIPoSoGtK0jANX\nykroFnXr4N3IL5TafDZVvMGNuWhWwS8JR3B0VDzPobt/jxPJKmGunZoCqwJC+nqT\nELanzRGdLk0G2chSGO7ZKGg=\n-----END PRIVATE KEY-----\n";
+export declare const cert = "-----BEGIN CERTIFICATE-----\nMIIDOjCCAiKgAwIBAgIUad1YSlfC6YFAqn38plnziyvx1/YwDQYJKoZIhvcNAQEL\nBQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MCAXDTI2MTAwNjA4NDU1OFoYDzIxMjYw\nOTEyMDg0NTU4WjAUMRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEB\nAQUAA4IBDwAwggEKAoIBAQDN0THQ8qpf3mMoNlVzVvjfsw/QHo22ojmmUO+3QjZD\neB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQVcqRTDFkk9zBnCagFIWCi2DI4VgAr\nzWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leKjvSW2021Ntp8VX+KV5nXM3rRUWaP\nUSGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBPTPt9BNVO0CXL8zsiQfNOveN4nTBm\nF4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5OnPERgwZhgIg15G7Y/vz9N0vZGmIU\n7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44DG7hvX8DVAgMBAAGjgYEwfzAdBgNV\nHQ4EFgQUzO7Y5K1NaU+/GXZJi2C47uK0+tQwHwYDVR0jBBgwFoAUzO7Y5K1NaU+/\nGXZJi2C47uK0+tQwDwYDVR0TAQH/BAUwAwEB/zAsBgNVHREEJTAjgglsb2NhbGhv\nc3SHBH8AAAGHEAAAAAAAAAAAAAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggEBAL/P\np3lI83Fcw8EpVyzr9QPYA7JZVmy8YlJ7vouOmEUi6X7BnK5Eits1uHGZ6rtLGBCY\nEu4Z4DnCPXnyXuo4Bzaqabs5qUro3Ztf0FXeatGCmTLx06JSapKVyoXkJpzLzX0u\npj0WfWUkwD3rGQozn0FOUOrZyjYgPgsqr6doWd5emAWl1L8ZGDFJEWPRvrS0dw7Z\nZG83/H0UYur8lN2JxV4ITRovftmtruiVNw3mXH5BZCIsoFAEtf3hssn6rekfEOfc\n4vty2NskN112OLQzLK1Oq3dl0C6Ns1MdIoelAHrFdeM3O03Y0D2R+PlNw1cU55if\nEF3engvuSVRtcV8eyxM=\n-----END CERTIFICATE-----\n";

package/dist/esm/cert.js

@@ -0,0 +1,4 @@
+// Generated by scripts/build.js from cert/. Do not edit by hand.
+// Self-signed certificate for localhost, used when the server options give no credentials
+export const key = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDN0THQ8qpf3mMo\nNlVzVvjfsw/QHo22ojmmUO+3QjZDeB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQV\ncqRTDFkk9zBnCagFIWCi2DI4VgArzWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leK\njvSW2021Ntp8VX+KV5nXM3rRUWaPUSGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBP\nTPt9BNVO0CXL8zsiQfNOveN4nTBmF4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5O\nnPERgwZhgIg15G7Y/vz9N0vZGmIU7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44D\nG7hvX8DVAgMBAAECggEABIVNSlEiM+PfGrGC0/s7kTJOLRyWsUXD7WbGtShDp9y6\nFQXaaIxNP1FoJyqHP/p5fHsBO310waK/gYcYm+hgBuNVEVZRdfdjN4B3LeyZqVyk\nLbbNwfRferwIswydLBsy4cpwdLQAflI15Qm5zpx3ivzu9J8uI3xEGUl8r59RmOE9\ntXb+sA9YtWRXUR4mhqApGxMI5ZP1/WbmhlDvLUnartyBNilfS3RTWY7nWMKk3U0N\nyFmYX17WZYnXbJtXQmOX/LHd1nM2NFS2B6yJ6JKY0/jPOGCaTBcVmFgO3x/aDgiJ\nm0XL1mpGBIUugQTio5N1Ewznrg6SA7rzsOzN1g3ZqwKBgQD48+lGyQmFAaaXzf+9\nWiG6F6hQtsiWDwhQ3C1m1fOMk2Fgi/eVPEWxIRbf18XBwgvt4Q7PoyojzR730YZl\n5WsEpliGyaBdrR4ZRh92t3y0fQ6Q/AMhsIEIu62lZbLlLenW5/OZLyVsuctAUZCg\nHBNgwR1wuvBBXrc+TIXjUYgsfwKBgQDTpLEqsjh8ZrCvubH0mlTCHkSS/A3ifk27\nsuLZhps0J0JMM1drxpNHcfySZ31sVrMZog1cf5W6z55pYlEDCrlEjK2gjyzJnmUA\nKE+ramKMH1/hfxdVZLY1F1zL2oLuprQEE6AUMDdZiv4JMcNfHA05Ii5VpsGe/sVe\naCiudjH4qwKBgFEFiMk5ynhYJjDHoVCt0cYvxt6l7jgwIkO2tKwAO6hnmsyCIQyX\nthLEsx4cqka58Yn0sg5Pivpl2otKzJPDC4ZS4QLVAfUaz23oTXskklhnTuNOsXI4\ncHY4JnZq18MQo0cG7FfRaTuuaADByvDg0kmt7/ftTx3nRnnnC7gEo+3fAoGAX4WG\nfNnBSsxiVH2ARwDc3lwg4SIn9iDBXsTnQ/xP0mMhthi6DSer02Qr9bwFzL74yMnu\nM+BVqOIKAlBgdfoCEmFYAA5+zWTS+xY2lwxF/C4w7SqaUm1JG3823774t1PADdL5\nvgLhCGYGMAoovqV/hljaBshjvSoJ1Ik4Sz2HYk8CgYEAnSqiwlpYZKQX7jBo7yWA\nxB6r81uUHwy+XOq7A4OfgbEEuuKQ6tXOg72FX+38rF+Td6iA+6qIPoSoGtK0jANX\nykroFnXr4N3IL5TafDZVvMGNuWhWwS8JR3B0VDzPobt/jxPJKmGunZoCqwJC+nqT\nELanzRGdLk0G2chSGO7ZKGg=\n-----END PRIVATE KEY-----\n";
+export const cert = "-----BEGIN CERTIFICATE-----\nMIIDOjCCAiKgAwIBAgIUad1YSlfC6YFAqn38plnziyvx1/YwDQYJKoZIhvcNAQEL\nBQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MCAXDTI2MTAwNjA4NDU1OFoYDzIxMjYw\nOTEyMDg0NTU4WjAUMRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEB\nAQUAA4IBDwAwggEKAoIBAQDN0THQ8qpf3mMoNlVzVvjfsw/QHo22ojmmUO+3QjZD\neB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQVcqRTDFkk9zBnCagFIWCi2DI4VgAr\nzWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leKjvSW2021Ntp8VX+KV5nXM3rRUWaP\nUSGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBPTPt9BNVO0CXL8zsiQfNOveN4nTBm\nF4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5OnPERgwZhgIg15G7Y/vz9N0vZGmIU\n7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44DG7hvX8DVAgMBAAGjgYEwfzAdBgNV\nHQ4EFgQUzO7Y5K1NaU+/GXZJi2C47uK0+tQwHwYDVR0jBBgwFoAUzO7Y5K1NaU+/\nGXZJi2C47uK0+tQwDwYDVR0TAQH/BAUwAwEB/zAsBgNVHREEJTAjgglsb2NhbGhv\nc3SHBH8AAAGHEAAAAAAAAAAAAAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggEBAL/P\np3lI83Fcw8EpVyzr9QPYA7JZVmy8YlJ7vouOmEUi6X7BnK5Eits1uHGZ6rtLGBCY\nEu4Z4DnCPXnyXuo4Bzaqabs5qUro3Ztf0FXeatGCmTLx06JSapKVyoXkJpzLzX0u\npj0WfWUkwD3rGQozn0FOUOrZyjYgPgsqr6doWd5emAWl1L8ZGDFJEWPRvrS0dw7Z\nZG83/H0UYur8lN2JxV4ITRovftmtruiVNw3mXH5BZCIsoFAEtf3hssn6rekfEOfc\n4vty2NskN112OLQzLK1Oq3dl0C6Ns1MdIoelAHrFdeM3O03Y0D2R+PlNw1cU55if\nEF3engvuSVRtcV8eyxM=\n-----END CERTIFICATE-----\n";

package/dist/esm/command-states.d.ts

@@ -0,0 +1,36 @@
+import type { CommandOptions } from './types.js';
+/** Command options with every key set, see commandOptions() */
+export interface ResolvedCommandOptions {
+    states: string[] | false;
+    noArguments: boolean;
+    mailboxArguments: number[];
+    astringArguments: number[];
+    searchCriteria: number | false;
+    sequenceSet: number | false;
+    noExpunge: boolean;
+    literal8: true | string | false;
+    noPipelining: boolean;
+    appendMessage: boolean;
+}
+/**
+ * Normalizes command options
+ *
+ * @param {Object|Array} options `{ states, noArguments, mailboxArguments, astringArguments, searchCriteria, sequenceSet, noExpunge,
+ *   literal8, noPipelining }`, or just the list of states
+ * @return {Object} options with all keys set
+ */
+declare function commandOptions(input?: CommandOptions | string[] | null): ResolvedCommandOptions;
+/**
+ * Returns the options of a core command
+ *
+ * @param {String} command Upper case command name, e.g. "UID FETCH"
+ * @return {Object|Boolean} command options (see commandOptions) or false if the command is not a core command
+ */
+declare function getCommandOptions(command: string): ResolvedCommandOptions | false;
+declare const states: {
+    ANY: string[];
+    NOT_AUTHENTICATED: string[];
+    AUTHENTICATED: string[];
+    SELECTED: string[];
+};
+export { getCommandOptions, commandOptions, states };

package/{lib → dist/esm}/command-states.js

@@ -1,12 +1,9 @@
-'use strict';
-
 // Connection states in which each command is valid (RFC 3501 sections 3 and 6). Commands valid
 // in the authenticated state are also valid in the selected state.
 const ANY = ['Not Authenticated', 'Authenticated', 'Selected'];
 const NOT_AUTHENTICATED = ['Not Authenticated'];
 const AUTHENTICATED = ['Authenticated', 'Selected'];
 const SELECTED = ['Selected'];
-
 /**
  * Normalizes command options
  *
@@ -14,11 +11,8 @@ const SELECTED = ['Selected'];
  *   literal8, noPipelining }`, or just the list of states
  * @return {Object} options with all keys set
  */
-function commandOptions(options) {
-    if (Array.isArray(options)) {
-        options = { states: options };
-    }
-    options = options || {};
+function commandOptions(input) {
+    const options = (Array.isArray(input) ? { states: input } : input) || {};
     return {
         // false means any state
         states: options.states ? [].concat(options.states) : false,
@@ -49,17 +43,14 @@ function commandOptions(options) {
         appendMessage: !!options.appendMessage
     };
 }
-
 // RFC 3501 core commands. Plugins pass the options of their commands to setCommandHandler
 const CORE_COMMANDS = {
     CAPABILITY: commandOptions({ states: ANY, noArguments: true }),
     NOOP: commandOptions({ states: ANY, noArguments: true }),
     LOGOUT: commandOptions({ states: ANY, noArguments: true }),
-
     STARTTLS: commandOptions({ states: NOT_AUTHENTICATED, noArguments: true, noPipelining: true }),
     // login = "LOGIN" SP userid SP password, both astrings
     LOGIN: commandOptions({ states: NOT_AUTHENTICATED, astringArguments: [0, 1] }),
-
     SELECT: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
     EXAMINE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
     CREATE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
@@ -72,7 +63,6 @@ const CORE_COMMANDS = {
     LSUB: commandOptions({ states: AUTHENTICATED, astringArguments: [0, 1] }),
     STATUS: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
     APPEND: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0], literal8: 'BINARY', appendMessage: true }),
-
     CHECK: commandOptions({ states: SELECTED, noArguments: true }),
     CLOSE: commandOptions({ states: SELECTED, noArguments: true }),
     EXPUNGE: commandOptions({ states: SELECTED, noArguments: true }),
@@ -83,10 +73,8 @@ const CORE_COMMANDS = {
     'UID COPY': commandOptions({ states: SELECTED, mailboxArguments: [1] }),
     'UID SEARCH': commandOptions({ states: SELECTED, searchCriteria: 0 })
 };
-
 const UID_COMMAND = commandOptions({ states: SELECTED });
 const AUTHENTICATE_COMMAND = commandOptions({ states: NOT_AUTHENTICATED });
-
 /**
  * Returns the options of a core command
  *
@@ -105,5 +93,5 @@ function getCommandOptions(command) {
     }
     return false;
 }
-
-module.exports = { getCommandOptions, commandOptions, states: { ANY, NOT_AUTHENTICATED, AUTHENTICATED, SELECTED } };
+const states = { ANY, NOT_AUTHENTICATED, AUTHENTICATED, SELECTED };
+export { getCommandOptions, commandOptions, states };

package/dist/esm/commands/append.d.ts

@@ -0,0 +1,88 @@
+import type { AppendMessage, Attribute, Callback, IMAPConnection, IMAPError, Mailbox, Message, ParsedCommand, Refusal } from '../types.js';
+/** A message of an APPEND like command, ready to be stored */
+export interface PreparedMessage extends AppendMessage {
+    flags: string[];
+    internaldate: string | false;
+    raw: string;
+    /** builds the message source of an append-data extension */
+    resolve?: (() => string) | undefined;
+    /** the message was sent as a literal8 */
+    literal8?: boolean | undefined;
+}
+/** The result of prepareAppend() */
+export interface PreparedAppend {
+    mailbox: Mailbox;
+    messages: PreparedMessage[];
+}
+/** Options of prepareAppend() */
+export interface PrepareAppendOptions {
+    command: string;
+    maxMessages?: number | undefined;
+    replaced?: Message | null | undefined;
+}
+/**
+ * Creates an error that refuses an APPEND like command
+ *
+ * @param {String} text Human readable text
+ * @param {String} [code] Response code, e.g. "TOOBIG"
+ * @param {Array} [codeArgs] Arguments of the response code, as response attributes
+ * @param {String} [response] "NO" (default) or "BAD"
+ * @return {Error} Error object
+ */
+declare function appendError(text: string, code?: string | false, codeArgs?: Attribute[] | false, response?: string): IMAPError;
+declare const badArgument: (text: string) => IMAPError;
+/**
+ * Finds the target mailbox name of an APPEND or REPLACE command when a literal of a message (or of a CATENATE TEXT
+ * part) is announced. Only the start of the command up to the mailbox argument is parsed, so the data of earlier
+ * literals is not parsed again for every message of a MULTIAPPEND
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {String|Boolean} storage name of the mailbox, or false if the literal is not a message or the name is not
+ *   known yet or not valid
+ */
+declare function getPendingTarget(connection: IMAPConnection, command: string, line: string): string | false;
+/**
+ * A literal filter (`server.literalFilters`) that refuses the message of an APPEND or REPLACE to a mailbox that does
+ * not exist before the client sends it, by not sending a continuation request (RFC 3502 section 6.3.11 example A004,
+ * RFC 3501 section 6.3.11: TRYCREATE). Not while earlier commands are still waiting, these could create the mailbox
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {Object|Boolean} `{ command, code, text }` to refuse the literal, or false
+ */
+declare function refuseMissingTarget(connection: IMAPConnection, command: string, line: string): Refusal | false;
+/**
+ * Prepares the messages of an APPEND like command (APPEND, REPLACE): parses the arguments, checks
+ * the target mailbox, builds the message sources and runs `server.appendChecks` through
+ * IMAPConnection#checkAppend. Nothing is stored yet, so a failure leaves every mailbox as it was
+ * (RFC 3502 section 6.3.11). The error response is sent here.
+ *
+ * The checks get the built messages (with `raw`) of the whole command and the options as
+ * `{ command, replaced }`, `replaced` is the message that REPLACE removes.
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Object} pathArg Parsed mailbox name argument
+ * @param {Array} args Parsed arguments after the mailbox name
+ * @param {Object} options `{ command, maxMessages, replaced }`
+ * @return {Object|Boolean} `{ mailbox, messages }` or false if an error response was sent
+ */
+declare function prepareAppend(connection: IMAPConnection, parsed: ParsedCommand, data: string, pathArg: Attribute, args: Attribute[], options: PrepareAppendOptions): PreparedAppend | false;
+/**
+ * Stores prepared messages. The sessions that have the target mailbox selected get EXISTS updates
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} prepared Result of prepareAppend()
+ * @return {Object} `{ mailbox, message, messages }`, message is the last stored message
+ */
+declare function storeMessages(connection: IMAPConnection, prepared: PreparedAppend): {
+    mailbox: Mailbox;
+    message: Message | undefined;
+    messages: Message[];
+};
+export default function appendCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+export { appendError, badArgument, prepareAppend, storeMessages, getPendingTarget, refuseMissingTarget };