imapkit 4.0.3 → 4.1.1

package/dist/cjs/plugins/esearch.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * @help Adds ESEARCH [RFC4731] capability
+ * @help SEARCH and UID SEARCH take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = esearchPlugin;
+const esearch_js_1 = require("../esearch.js");
+const search_js_1 = require("../commands/handlers/search.js");
+// RFC 4466 section 2.6.1: search = "SEARCH" [SP "RETURN" SP "(" [search-return-opt *(SP search-return-opt)] ")"] SP search-program
+const hasReturnOptions = (attributes) => {
+    const first = attributes && attributes[0];
+    return !!first && first.type === 'ATOM' && String(first.value).toUpperCase() === 'RETURN';
+};
+function esearchPlugin(server) {
+    // SEARCHRES loads ESEARCH as well, so the plugin may be called twice
+    if (server.searchReturnOptions) {
+        return;
+    }
+    server.registerCapability('ESEARCH');
+    // RFC 4731 section 3.1 result options. Other plugins add their own: `data: false` for an option that
+    // does not add data to the ESEARCH response (SAVE of SEARCHRES), `response: true` if the ESEARCH
+    // response is sent even then (UPDATE of CONTEXT=SEARCH), `hint: true` for an option that is accepted
+    // and ignored (CONTEXT), `parse(item)` for an option with an argument and `once: true` if the option
+    // must not be repeated
+    server.searchReturnOptions = new Map(['MIN', 'MAX', 'ALL', 'COUNT'].map(name => [name, { data: true }]));
+    // Checks of the whole list of result options, `(options, connection, parsed, names)` returns an error message
+    // for an invalid combination. `names` also holds the hint options
+    server.searchReturnChecks = [];
+    /**
+     * Parses a list of result options (RFC 4466 section 2.6.1: search-return-opts)
+     *
+     * @param {Array} list Parsed list of result options
+     * @param {Object} connection IMAP connection
+     * @param {Object} parsed Parsed command
+     * @return {Map} upper case option names to their parsed arguments (true for options without one)
+     * @throws {Error} BAD error for an invalid list
+     */
+    server.parseSearchReturn = (list, connection, parsed) => {
+        if (!Array.isArray(list)) {
+            throw (0, search_js_1.badError)('RETURN expects a parenthesized list of result options');
+        }
+        const options = new Map();
+        // every option name, also the hints that are left out of `options`
+        const names = new Set();
+        for (let i = 0; i < list.length; i++) {
+            const item = list[i];
+            const name = item && item.type === 'ATOM' ? String(item.value).toUpperCase() : '';
+            const spec = server.searchReturnOptions.get(name);
+            // options that the server does not support must be rejected with BAD (RFC 4466 section 2.6.1)
+            if (!spec) {
+                throw (0, search_js_1.badError)('Unknown SEARCH result option' + (name ? ' ' + name : ''));
+            }
+            if (spec.once && options.has(name)) {
+                throw (0, search_js_1.badError)('SEARCH result option ' + name + ' can be used only once');
+            }
+            names.add(name);
+            const value = spec.parse ? spec.parse(list[++i]) : true;
+            if (!spec.hint) {
+                options.set(name, value);
+            }
+        }
+        for (const check of server.searchReturnChecks) {
+            const error = check(options, connection, parsed, names);
+            if (error) {
+                throw (0, search_js_1.badError)(error);
+            }
+        }
+        return options;
+    };
+    // only result options without return data, like SAVE (RFC 5182 section 1), suppress the ESEARCH response
+    server.isSilentReturn = (options) => options.size > 0 &&
+        ![...options.keys()].some(name => {
+            const spec = server.searchReturnOptions.get(name);
+            return spec.data || spec.response;
+        });
+    // The result options are taken off the arguments, so the SEARCH handler only sees the search program
+    const searchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        if (!hasReturnOptions(parsed.attributes)) {
+            return prevHandler(connection, parsed, data, callback);
+        }
+        try {
+            parsed.searchReturn = server.parseSearchReturn(parsed.attributes[1], connection, parsed);
+        }
+        catch (E) {
+            connection.sendStatus(parsed, data, 'BAD', E.message, false, (parsed.command || '').toUpperCase() + ' FAILED');
+            return callback();
+        }
+        parsed.attributes = parsed.attributes.slice(2);
+        prevHandler(connection, parsed, data, callback);
+    };
+    // Lets a command take result options before its other arguments, parsed into `parsed.searchReturn`.
+    // ESORT uses it for SORT and UID SORT (RFC 5267 section 3)
+    server.acceptSearchReturn = (command) => {
+        const prevHandler = server.getCommandHandler(command);
+        server.setCommandHandler(command, (connection, parsed, data, callback) => searchWrapper(prevHandler, connection, parsed, data, callback));
+    };
+    server.acceptSearchReturn('SEARCH');
+    server.acceptSearchReturn('UID SEARCH');
+    // RFC 3501 section 5.5: only the search program can hold sequence numbers, the result options do not
+    server.connectionHandlers.push((connection) => {
+        const usesSequenceNumbers = connection.usesSequenceNumbers;
+        connection.usesSequenceNumbers = function (parsed) {
+            if (hasReturnOptions(parsed.attributes)) {
+                parsed = Object.assign({}, parsed, { attributes: parsed.attributes.slice(2) });
+            }
+            return usesSequenceNumbers.call(this, parsed);
+        };
+    });
+    // Replaces the SEARCH response of an extended SEARCH with a single ESEARCH response (RFC 4731 section 3.1)
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (!parsed ||
+            !parsed.searchReturn ||
+            response.tag !== '*' ||
+            response.command !== 'SEARCH' ||
+            (description !== 'SEARCH' && description !== 'UID SEARCH') ||
+            !extra ||
+            !Array.isArray(extra.list)) {
+            return;
+        }
+        response.skipResponse = true;
+        const options = parsed.searchReturn;
+        if (server.isSilentReturn(options)) {
+            return;
+        }
+        // like for SEARCH, the extra data is the search result, but `list` only holds the messages that the
+        // result options return (RFC 4731 section 3.2), for the MODSEQ of CONDSTORE
+        connection.send((0, esearch_js_1.buildEsearchResponse)(parsed.tag, description === 'UID SEARCH', extra, options), 'ESEARCH', parsed, data, Object.assign({}, extra, { list: (0, esearch_js_1.selectReturned)(extra.list, options) }));
+    });
+}
+{
+    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/plugins/esort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds ESORT [RFC5267] capability, loads SORT and ESEARCH as well
+ * @help SORT and UID SORT take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH, results are in sort order
+ */
+import type { IMAPServer } from '../types.js';
+export default function esortPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/esort.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * @help Adds ESORT [RFC5267] capability, loads SORT and ESEARCH as well
+ * @help SORT and UID SORT take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH, results are in sort order
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = esortPlugin;
+const sort_js_1 = __importDefault(require("./sort.js"));
+const esearch_js_1 = __importDefault(require("./esearch.js"));
+const esearch_js_2 = require("../esearch.js");
+const isSort = (command) => command === 'SORT' || command === 'UID SORT';
+function esortPlugin(server) {
+    if (server.esortLoaded) {
+        return;
+    }
+    server.esortLoaded = true;
+    (0, sort_js_1.default)(server);
+    (0, esearch_js_1.default)(server);
+    server.registerCapability('ESORT');
+    // RFC 5267 section 3: extended-sort = ["UID" SP] "SORT" search-return-opts SP sort-criteria SP search-criteria
+    server.acceptSearchReturn('SORT');
+    server.acceptSearchReturn('UID SORT');
+    // RFC 5267 section 4.1: the CONTEXT, UPDATE and PARTIAL result options of SORT come with CONTEXT=SORT. PARTIAL
+    // is also defined for the PARTIAL capability (RFC 9394 section 3.1)
+    server.searchReturnChecks.push((options, connection, parsed, names) => {
+        if (!isSort((parsed.command || '').toUpperCase()) || server.contextSort) {
+            return false;
+        }
+        const name = ['CONTEXT', 'UPDATE', 'PARTIAL'].find(key => names.has(key) && (key !== 'PARTIAL' || !server.partialRangeLast));
+        return !!name && name + ' is not supported for SORT';
+    });
+    // Replaces the SORT response of an extended SORT with an ESEARCH response (RFC 5267 section 3)
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (!parsed || !parsed.searchReturn || response.tag !== '*' || response.command !== 'SORT' || !isSort(description) || !extra || !extra.sorted) {
+            return;
+        }
+        response.skipResponse = true;
+        const options = parsed.searchReturn;
+        if (server.isSilentReturn(options)) {
+            return;
+        }
+        // the extra data lists the returned messages, for the MODSEQ of CONDSTORE (RFC 7162 section 3.1.10)
+        connection.send((0, esearch_js_2.buildEsearchResponse)(parsed.tag, description === 'UID SORT', extra, options, null, extra.sorted), 'ESEARCH', parsed, data, Object.assign({}, extra, { list: (0, esearch_js_2.selectReturned)(extra.sorted, options) }));
+    });
+}
+{
+    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/plugins/id.d.ts

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds ID [RFC2971] capability
+ */
+export default function idPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/id.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = idPlugin;
+const command_states_js_1 = require("../command-states.js");
+/**
+ * @help Adds ID [RFC2971] capability
+ */
+function idPlugin(server) {
+    // Register capability, always usable
+    server.registerCapability('ID');
+    // Add ID command
+    server.setCommandHandler('ID', (connection, parsed, data, callback) => {
+        // keys are client supplied, so the object has no prototype
+        const clientList = Object.create(null);
+        let serverList = null;
+        let i;
+        let len;
+        let key = '';
+        // Require exactly 1 attribute (NIL or parameter list)
+        if (!parsed.attributes || parsed.attributes.length !== 1) {
+            return sendError('ID expects 1 attribute', connection, parsed, data, callback);
+        }
+        const list = parsed.attributes[0];
+        if ((list && !Array.isArray(list)) || (list && list.length % 2)) {
+            return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+        }
+        // RFC 2971 section 3.3: at most 30 field-value pairs
+        if (list && list.length > 60) {
+            return sendError('ID allows at most 30 field-value pairs', connection, parsed, data, callback);
+        }
+        // Build client ID object and check validity of the values
+        if (list && list.length) {
+            for (i = 0, len = list.length; i < len; i++) {
+                if (i % 2 === 0) {
+                    // Handle keys (always strings)
+                    if (list[i] && ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
+                        key = list[i].value;
+                        // RFC 2971 section 3.3: field names are at most 30 octets, case-insensitive and unique
+                        if (key.length > 30) {
+                            return sendError('ID field names can be at most 30 octets', connection, parsed, data, callback);
+                        }
+                        if (Object.keys(clientList).some(existing => existing.toLowerCase() === key.toLowerCase())) {
+                            return sendError('ID field names must not repeat', connection, parsed, data, callback);
+                        }
+                    }
+                    else {
+                        return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+                    }
+                }
+                else {
+                    // Handle values (string or NIL)
+                    if (!list[i] || ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
+                        if (list[i] && list[i].value.length > 1024) {
+                            return sendError('ID values can be at most 1024 octets', connection, parsed, data, callback);
+                        }
+                        clientList[key] = (list[i] && list[i].value) || null;
+                    }
+                    else {
+                        return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+                    }
+                }
+            }
+        }
+        // Build response object from server options
+        if (server.options.id) {
+            const ids = [];
+            serverList = ids;
+            Object.keys(server.options.id).forEach(key => {
+                ids.push({
+                    type: 'STRING',
+                    value: key
+                });
+                ids.push({
+                    type: 'STRING',
+                    value: (server.options.id[key] || '').toString()
+                });
+            });
+        }
+        // Send untagged ID response
+        connection.send({
+            tag: '*',
+            command: 'ID',
+            attributes: [serverList]
+        }, 'ID', parsed, data, clientList);
+        // Send tagged response
+        connection.send({
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'ID command completed'
+                }
+            ]
+        }, 'ID', parsed, data, clientList);
+        callback();
+    }, { states: command_states_js_1.states.ANY });
+}
+function sendError(message, connection, parsed, data, callback) {
+    connection.send({
+        tag: parsed.tag,
+        command: 'BAD',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: message
+            }
+        ]
+    }, 'INVALID COMMAND', parsed, data);
+    return callback();
+}
+{
+    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/plugins/idle.d.ts

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds IDLE [RFC2177] capability
+ */
+export default function idlePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/idle.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = idlePlugin;
+const command_states_js_1 = require("../command-states.js");
+/**
+ * @help Adds IDLE [RFC2177] capability
+ */
+function idlePlugin(server) {
+    server.registerCapability('IDLE');
+    server.setCommandHandler('IDLE', (connection, parsed, data, callback) => {
+        const idleTimer = setTimeout(() => {
+            if (connection.socket && !connection.socket.destroyed) {
+                connection.send({
+                    tag: '*',
+                    command: 'BYE',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'IDLE terminated'
+                        }
+                    ]
+                }, 'IDLE EXPIRED', parsed, data);
+                connection.end();
+            }
+        }, 30 * 60 * 1000);
+        // An idling client should not keep the process alive
+        idleTimer.unref();
+        const clearIdleTimer = () => clearTimeout(idleTimer);
+        const socket = connection.socket;
+        if (socket) {
+            socket.once('close', clearIdleTimer);
+        }
+        connection.directNotifications = true;
+        // Temporarily redirect client input to this function
+        connection.inputHandler = function (str) {
+            clearIdleTimer();
+            if (socket) {
+                socket.removeListener('close', clearIdleTimer);
+            }
+            // Stop listening to any other user input
+            connection.inputHandler = false;
+            // Notifications are sent again only while a command is in progress
+            connection.directNotifications = false;
+            if (str.toUpperCase() === 'DONE') {
+                connection.send({
+                    tag: parsed.tag,
+                    command: 'OK',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'IDLE terminated'
+                        }
+                    ]
+                }, 'IDLE', parsed, data);
+            }
+            else {
+                connection.send({
+                    tag: parsed.tag,
+                    command: 'BAD',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'Invalid Idle continuation'
+                        }
+                    ]
+                }, 'INVALID IDLE', parsed, data);
+            }
+        };
+        connection.write('+ idling\r\n');
+        connection.processNotifications();
+        return callback();
+    }, { states: command_states_js_1.states.AUTHENTICATED, noArguments: true });
+}
+{
+    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/plugins/imap4rev2.d.ts

@@ -0,0 +1,6 @@
+import type { IMAPServer } from '../types.js';
+declare function imap4rev2Plugin(server: IMAPServer): void;
+declare namespace imap4rev2Plugin {
+    var requires: string[];
+}
+export default imap4rev2Plugin;

package/dist/cjs/plugins/imap4rev2.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = imap4rev2Plugin;
+const utf8_session_js_1 = require("../utf8-session.js");
+const literalminus_js_1 = __importDefault(require("./literalminus.js"));
+const enable_js_1 = require("./enable.js");
+/**
+ * @help Adds IMAP4rev2 [RFC9051] capability next to IMAP4rev1 and loads
+ * @help the extensions folded into IMAP4rev2 (RFC 9051 Appendix E).
+ * @help A session follows RFC 9051 after ENABLE IMAP4rev2, others RFC 3501
+ */
+// RFC 9051 Appendix A: a client that wants IMAP4rev2 when both revisions are advertised MUST issue "ENABLE IMAP4rev2".
+// The ENABLE plugin lists enabled extensions in this spelling
+const REV2 = 'IMAP4rev2';
+// RFC 9051 section 9 leaves these IMAP4rev1 items out of the search-key, status-att and fetch-att rules (Appendix E
+// items 12 and 18), so an IMAP4rev2 session gets BAD for them
+const REMOVED_SEARCH_KEYS = new Set(['NEW', 'OLD', 'RECENT', 'UNRECENT']);
+const REMOVED_STATUS_ITEMS = new Set(['RECENT']);
+// RFC 9051 section 6.3.11 and Appendix E item 3: STATUS DELETED is new in IMAP4rev2 (STATUS SIZE comes with STATUS=SIZE)
+const ADDED_STATUS_ITEMS = new Set(['DELETED']);
+const REMOVED_FETCH_ITEMS = new Set(['RFC822', 'RFC822.HEADER', 'RFC822.TEXT']);
+// RFC 9051 section 2.3.2: keywords that SHOULD be allowed in SEARCH and preserved in APPEND, COPY and MOVE
+const KEYWORDS = ['$Forwarded', '$MDNSent', '$Junk', '$NotJunk', '$Phishing'];
+// set by setMode() below
+const isRev2 = (connection) => !!connection.imap4rev2;
+const atomName = (attr) => (attr && attr.type === 'ATOM' ? String(attr.value).toUpperCase() : '');
+function imap4rev2Plugin(server) {
+    // RFC 9051 Appendix A: advertised together with IMAP4rev1 (capability.ts always lists it), so every session
+    // starts as IMAP4rev1 (section 7.2.2) and ENABLE switches it (section 6.3.1)
+    server.registerCapability('IMAP4rev2');
+    (0, enable_js_1.registerEnable)(server, REV2);
+    // RFC 9051 section 4.3 and Appendix E item 2: non-synchronizing literals up to 4096 octets (LITERAL-). LITERAL+
+    // allows more, so it is kept if it is loaded already, and it can replace this LITERAL- when it is loaded later
+    if (!server.capabilities['LITERAL+'] && !server.capabilities['LITERAL-']) {
+        (0, literalminus_js_1.default)(server);
+        server.impliedLiteralMinus = true;
+    }
+    // RFC 9051 section 2.3.2: a mailbox that does not allow new keywords (no "\*" in PERMANENTFLAGS) still keeps these
+    server.mailboxHandlers.push((server, mailbox) => {
+        if (!mailbox.allowPermanentFlags) {
+            KEYWORDS.forEach(keyword => server.ensureFlag(mailbox.permanentFlags, keyword));
+        }
+    });
+    // The session follows RFC 9051 once IMAP4rev2 is enabled
+    const setMode = (connection) => {
+        const rev2 = (connection.imap4rev2 = (0, enable_js_1.isEnabled)(connection, REV2));
+        // UTF-8 in quoted strings and mailbox names (sections 4.3 and 5.1), SEARCH assumes UTF-8 (section 6.4.4)
+        (0, utf8_session_js_1.updateSession)(connection);
+        // message/global encapsulates a message like message/rfc822 (sections 6.4.5.1 and 7.5.2)
+        connection.messageGlobal = rev2;
+        connection.disabledSearchKeys = rev2 ? REMOVED_SEARCH_KEYS : null;
+        // literal sizes, partial ranges (parsed by imap-handler), LARGER and SMALLER are number64 (section 9, Appendix E item 1)
+        connection.number64 = connection.parserOptions.number64 = rev2;
+        connection.disabledStatusItems = rev2 ? REMOVED_STATUS_ITEMS : null;
+        // only for this session, an IMAP4rev1 session gets DELETED only from plugins that add it for everyone (QUOTA)
+        connection.addedStatusItems = rev2 ? ADDED_STATUS_ITEMS : null;
+        if (rev2) {
+            // \Recent is deprecated (section 2.3.2, Appendix E item 12), an IMAP4rev2 session does not see it
+            connection.getFlags = (message) => message.flags;
+        }
+        else {
+            // back to IMAPConnection#getFlags
+            delete connection.getFlags;
+        }
+    };
+    server.connectionHandlers.push(setMode);
+    // RFC 8437 section 4.1: UNAUTHENTICATE turns ENABLEd extensions off
+    server.resetHandlers.push(setMode);
+    const sendBad = (connection, parsed, data, callback, text) => {
+        connection.sendStatus(parsed, data, 'BAD', text);
+        return callback();
+    };
+    // Wraps the handler of a command, `wrapper(prevHandler, connection, parsed, data, callback)` runs instead
+    const wrap = (command, wrapper) => {
+        const prevHandler = server.getCommandHandler(command);
+        server.setCommandHandler(command, (connection, parsed, data, callback) => wrapper(prevHandler, connection, parsed, data, callback));
+    };
+    // Appendix E item 17: CHECK was removed, NOOP does the same. Item 19: LSUB was deprecated and left out of the
+    // section 9 grammar, LIST (SUBSCRIBED) replaces it
+    Object.entries({ CHECK: 'NOOP', LSUB: 'LIST (SUBSCRIBED)' }).forEach(([command, replacement]) => {
+        wrap(command, (prevHandler, connection, parsed, data, callback) => {
+            if (isRev2(connection)) {
+                return sendBad(connection, parsed, data, callback, command + ' is not part of IMAP4rev2, use ' + replacement + ' (RFC 9051 Appendix E)');
+            }
+            prevHandler(connection, parsed, data, callback);
+        });
+    });
+    // Appendix E item 18: RFC822, RFC822.HEADER and RFC822.TEXT are not fetch-att items any more, BODY[], BODY.PEEK[HEADER]
+    // and BODY[TEXT] replace them. RFC822.SIZE stays
+    const fetchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        const items = (parsed.attributes || [])[1];
+        if (isRev2(connection) && [].concat(items || []).some(item => REMOVED_FETCH_ITEMS.has(atomName(item)))) {
+            return sendBad(connection, parsed, data, callback, 'RFC822, RFC822.HEADER and RFC822.TEXT are not part of IMAP4rev2, use BODY[] (RFC 9051 Appendix E)');
+        }
+        prevHandler(connection, parsed, data, callback);
+    };
+    wrap('FETCH', fetchWrapper);
+    wrap('UID FETCH', fetchWrapper);
+    // Appendix E item 4 and section 6.4.4: SEARCH answers with ESEARCH, without result options it is RETURN (ALL).
+    // The ESEARCH plugin replaces the SEARCH response once `parsed.searchReturn` is set
+    const searchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        if (isRev2(connection) && atomName((parsed.attributes || [])[0]) !== 'RETURN') {
+            parsed.searchReturn = server.parseSearchReturn([], connection, parsed);
+        }
+        prevHandler(connection, parsed, data, callback);
+    };
+    wrap('SEARCH', searchWrapper);
+    wrap('UID SEARCH', searchWrapper);
+    // Appendix E item 9 and section 6.3.2: SELECT and EXAMINE report CLOSED when they close the selected mailbox
+    server.closedChecks.push(isRev2);
+    // Untagged LIST response for the selected mailbox (section 6.3.2, Appendix E item 10), with accurate attributes.
+    // Not a "LIST ITEM" response, that ACL would hide for a mailbox the user may read but not list
+    const sendMailboxList = (connection, mailbox, parsed, data) => {
+        // the special-use attributes of SPECIAL-USE are mailbox attributes in IMAP4rev2 (section 7.3.1)
+        const attributes = mailbox.flags.concat(mailbox['special-use'] || []);
+        connection.send({
+            tag: '*',
+            command: 'LIST',
+            attributes: [
+                attributes.map(flag => ({ type: 'ATOM', value: flag })),
+                server.getSeparator(mailbox),
+                // the canonical name, converted for the session in IMAPConnection#send
+                { type: 'MAILBOX', value: mailbox.path }
+            ]
+        }, 'SELECT LIST', parsed, data, mailbox);
+    };
+    server.outputHandlers.push((connection, response, description, parsed, data) => {
+        if (!parsed || !response || !isRev2(connection)) {
+            return;
+        }
+        const command = String(parsed.command || '').toUpperCase();
+        if (command !== 'SELECT' && command !== 'EXAMINE') {
+            return;
+        }
+        // Appendix E items 11 and 12: the RECENT response and the UNSEEN response code are deprecated
+        if (description === command + ' RECENT' || description === command + ' UNSEEN') {
+            response.skipResponse = true;
+            return;
+        }
+        if (description === command && response.tag === parsed.tag && response.command === 'OK' && connection.selectedMailbox) {
+            sendMailboxList(connection, connection.selectedMailbox, parsed, data);
+        }
+    });
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (description === 'ENABLED' && Array.isArray(extra) && extra.indexOf(REV2) >= 0) {
+            setMode(connection);
+        }
+    });
+}
+// RFC 9051 Appendix E item 2 lists the extensions that IMAP4rev2 folds in. With them the plugins advertise their own
+// capabilities, which RFC 9051 Appendix A suggests for a server that supports both revisions. AUTH=PLAIN is a MUST
+// (section 6.1.1). LITERAL- is loaded by the plugin itself, unless LITERAL+ is loaded
+imap4rev2Plugin.requires = [
+    'ENABLE',
+    'NAMESPACE',
+    'UNSELECT',
+    'UIDPLUS',
+    'ESEARCH',
+    'SEARCHRES',
+    'IDLE',
+    'SASL-IR',
+    'LIST-EXTENDED',
+    'LIST-STATUS',
+    'MOVE',
+    'BINARY',
+    'SPECIAL-USE',
+    'STATUS=SIZE',
+    'AUTH=PLAIN'
+];
+{
+    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/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../types.js';
+export declare const plugins: Record<string, Plugin>;