imapkit 4.0.3 → 4.1.1

package/dist/cjs/bodystructure.js

@@ -0,0 +1,150 @@
+"use strict";
+// Converts a parsed MIME tree into BODY and BODYSTRUCTURE data. Ported from WildDuck
+// (imap-core/lib/indexer/body-structure.js)
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const envelope_js_1 = __importDefault(require("./envelope.js"));
+const mimeparser_js_1 = require("./mimeparser.js");
+// Expose to the world
+exports.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
+ */
+function createBodystructure(tree, options) {
+    options = options || {};
+    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) => {
+        if (!parsed || !parsed.hasParams) {
+            return null;
+        }
+        const list = [];
+        // 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 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 {
+                bodyType = 'application';
+                bodySubtype = 'octet-stream';
+            }
+        }
+        return [
+            key(bodyType),
+            key(bodySubtype),
+            // body parameter parenthesized list
+            paramList(contentType),
+            // body id
+            node.parsedHeader['content-id'] || null,
+            // body description
+            node.parsedHeader['content-description'] || null,
+            // body encoding
+            key(node.parsedHeader['content-transfer-encoding'] || '7bit'),
+            // body size
+            node.size
+        ];
+    };
+    // The extension fields every part has (a non-multipart part also has an MD5 before them)
+    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)
+        // see note for "Section 7.4.2, page 75"
+        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) => {
+        let data = getBasicFields(node).concat(extra);
+        if (!options.body) {
+            data = data.concat([node.parsedHeader['content-md5'] || null], getExtensionFields(node));
+        }
+        return data;
+    };
+    const processMultipartNode = (node) => {
+        // only called for a node with parts
+        let data = (0, mimeparser_js_1.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 contentType = node.parsedHeader['content-type'] || {};
+        switch (contentType.type) {
+            case 'multipart':
+                // a multipart without a boundary parameter has no parts and is described with the
+                // basic fields (RFC 3501 body-type-mpart needs at least one body)
+                return (0, mimeparser_js_1.partsOf)(node) ? processMultipartNode(node) : processLeaf(node, []);
+            case 'text':
+                return processLeaf(node, [node.lineCount]);
+            case 'message': {
+                // RFC 2045 5.1: the subtype is not case sensitive. Other message subtypes, such as
+                // message/delivery-status, are described as basic parts. RFC 9051 section 9 media-message
+                // adds message/global, RFC 3501 body-type-basic describes it as a basic part
+                // (embeddedMessage() only returns the message of these types)
+                const embedded = (0, mimeparser_js_1.embeddedMessage)(node, options.messageGlobal);
+                if (embedded) {
+                    return processLeaf(node, [(0, envelope_js_1.default)(embedded.parsedHeader), walker(embedded), node.lineCount]);
+                }
+                return processLeaf(node, []);
+            }
+            default:
+                return processLeaf(node, []);
+        }
+    };
+    return walker(tree);
+}
+{
+    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/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/cjs/cert.js

@@ -0,0 +1,7 @@
+"use strict";
+// Generated by scripts/build.js from cert/. Do not edit by hand.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cert = exports.key = void 0;
+// Self-signed certificate for localhost, used when the server options give no credentials
+exports.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";
+exports.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/cjs/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/dist/cjs/command-states.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.states = void 0;
+exports.getCommandOptions = getCommandOptions;
+exports.commandOptions = commandOptions;
+// 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
+ *
+ * @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
+ */
+function commandOptions(input) {
+    const options = (Array.isArray(input) ? { states: input } : input) || {};
+    return {
+        // false means any state
+        states: options.states ? [].concat(options.states) : false,
+        // "Arguments: none" in the command description
+        noArguments: !!options.noArguments,
+        // positions of the arguments that are mailbox names, checked against RFC 3501 section 5.1.3
+        mailboxArguments: [].concat(options.mailboxArguments || []),
+        // positions of other arguments that are astrings (RFC 3501 section 9), like user names. In these, in the mailbox
+        // name arguments and in search criteria a NIL atom is a string, not the nil of an nstring
+        astringArguments: [].concat(options.astringArguments || []),
+        // position of the first search key argument, for commands that take search criteria (RFC 3501 section 6.4.4)
+        searchCriteria: typeof options.searchCriteria === 'number' ? options.searchCriteria : false,
+        // position of the argument that holds message sequence numbers (a sequence set or a seq-number, not UIDs), for
+        // the RFC 3501 section 5.5 ambiguity check and for UIDONLY (RFC 9586 section 3)
+        sequenceSet: typeof options.sequenceSet === 'number' ? options.sequenceSet : false,
+        // EXPUNGE responses must not be sent while the command runs, so a client does not have to wait for its
+        // completion before sending a command with sequence numbers (RFC 3501 sections 5.5 and 7.4.1)
+        noExpunge: !!options.noExpunge,
+        // if the command accepts literal8 arguments `~{n}`: true, or the capability that allows them, like
+        // "BINARY" for the APPEND message (RFC 3516 section 4.4)
+        literal8: options.literal8 === true || typeof options.literal8 === 'string' ? options.literal8 : false,
+        // the client must not send anything after the command before it has seen the result, because the command changes
+        // the layers below the protocol (STARTTLS, RFC 9051 section 6.2.1, COMPRESS, RFC 4978 section 3). The command is
+        // refused with BAD if more input is waiting
+        noPipelining: !!options.noPipelining,
+        // the command takes a message after its mailbox argument like APPEND does (REPLACE, RFC 8508 section 3.4), so a
+        // message literal to a missing mailbox is refused before it is sent
+        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] }),
+    DELETE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    RENAME: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0, 1] }),
+    SUBSCRIBE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    UNSUBSCRIBE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    // the reference is a mailbox name, the pattern a list-mailbox, an atom NIL is a valid name for both
+    LIST: commandOptions({ states: AUTHENTICATED, astringArguments: [0, 1] }),
+    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 }),
+    SEARCH: commandOptions({ states: SELECTED, searchCriteria: 0, noExpunge: true }),
+    FETCH: commandOptions({ states: SELECTED, sequenceSet: 0, noExpunge: true }),
+    STORE: commandOptions({ states: SELECTED, sequenceSet: 0, noExpunge: true }),
+    COPY: commandOptions({ states: SELECTED, sequenceSet: 0, mailboxArguments: [1] }),
+    '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
+ *
+ * @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
+ */
+function getCommandOptions(command) {
+    if (Object.hasOwn(CORE_COMMANDS, command)) {
+        return CORE_COMMANDS[command];
+    }
+    if (/^UID /.test(command)) {
+        return UID_COMMAND;
+    }
+    if (/^AUTHENTICATE /.test(command)) {
+        return AUTHENTICATE_COMMAND;
+    }
+    return false;
+}
+const states = { ANY, NOT_AUTHENTICATED, AUTHENTICATED, SELECTED };
+exports.states = states;

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