imapkit 4.0.3 → 4.1.1

package/dist/cjs/plugins/context-search.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * @help Adds CONTEXT=SEARCH [RFC5267] capability, loads ESEARCH as well
+ * @help SEARCH RETURN (UPDATE) sends ADDTO and REMOVEFROM updates as the result changes, until CANCELUPDATE or the mailbox is closed
+ * @help SEARCH RETURN (PARTIAL 1:100) returns a window of the results, the CONTEXT hint is accepted and ignored
+ * @help Server option "maxSearchContexts" (default 10) limits the updating contexts of a session, above it NOUPDATE is sent
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = contextSearchPlugin;
+const esearch_js_1 = __importDefault(require("./esearch.js"));
+const esearch_js_2 = require("../esearch.js");
+const command_states_js_1 = require("../command-states.js");
+const DEFAULT_MAX_CONTEXTS = 10;
+// commands that close the selected mailbox, updates cease with them (RFC 5267 section 4.3)
+const CLOSING_COMMANDS = new Set(['SELECT', 'EXAMINE', 'CLOSE', 'UNSELECT']);
+// searching commands that can create updating contexts, SORT and UID SORT only with CONTEXT=SORT (see the ESORT plugin)
+const SEARCHING_COMMANDS = new Set(['SEARCH', 'UID SEARCH', 'SORT', 'UID SORT']);
+const getContexts = (connection) => {
+    if (!connection.searchContexts) {
+        connection.searchContexts = new Map();
+    }
+    return connection.searchContexts;
+};
+/**
+ * Groups updates of one kind into context position and result set pairs (RFC 5267 sections 4.3.3 and
+ * 4.3.4). Updates of a searching command all use position 0 and form one set in mailbox order. Updates of
+ * a sorting command are merged while they continue each other: an insertion right after the previous
+ * inserted results, or a removal at the same position where the previous result was removed
+ *
+ * @param {Array} updates `[position, value]` pairs in the order they are applied
+ * @param {Boolean} isRemoval If true, the updates are REMOVEFROM updates
+ * @return {Array} payload of the ADDTO or REMOVEFROM return data item
+ */
+const groupUpdates = (updates, isRemoval) => {
+    const groups = [];
+    updates.forEach(([position, value]) => {
+        const last = groups[groups.length - 1];
+        const next = last && (isRemoval || !position ? last.position : last.position + last.values.length);
+        if (last && position === next) {
+            last.values.push(value);
+        }
+        else {
+            groups.push({ position, values: [value] });
+        }
+    });
+    const payload = [];
+    groups.forEach(group => {
+        const set = group.position ? (0, esearch_js_2.toOrderedSet)(group.values) : (0, esearch_js_2.toSequenceSet)(group.values);
+        payload.push(group.position, { type: 'SEQUENCE', value: set });
+    });
+    return payload;
+};
+/**
+ * Sends ADDTO and REMOVEFROM updates of a context (RFC 5267 sections 4.3.3 and 4.3.4)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} context Updating context
+ * @param {Array} removed `[position, value]` pairs of removed results, applied first
+ * @param {Array} added `[position, value]` pairs of added results
+ */
+const sendUpdate = (connection, context, removed, added) => {
+    const attributes = [(0, esearch_js_2.buildCorrelator)(context.tag, context.correlatorMailbox)];
+    if (context.isUid) {
+        attributes.push({ type: 'ATOM', value: 'UID' });
+    }
+    if (removed.length) {
+        attributes.push({ type: 'ATOM', value: 'REMOVEFROM' }, groupUpdates(removed, true));
+    }
+    if (added.length) {
+        attributes.push({ type: 'ATOM', value: 'ADDTO' }, groupUpdates(added, false));
+    }
+    connection.send({ tag: '*', command: 'ESEARCH', attributes }, 'ESEARCH UPDATE', null, null, context);
+};
+/**
+ * Checks every updating context against the selected mailbox as the session sees it, and sends the
+ * changes. Expunged messages are handled when their EXPUNGE response is sent
+ */
+const checkContexts = (connection) => {
+    const contexts = connection.searchContexts;
+    const mailbox = connection.selectedMailbox;
+    const messages = mailbox ? mailbox.messages : [];
+    const numbers = new Map(messages.map((message, i) => [message, i + 1]));
+    contexts.forEach((context, tag) => {
+        if (context.mailbox !== mailbox) {
+            contexts.delete(tag);
+            return;
+        }
+        const matching = messages.filter((message, i) => context.matches(message, i + 1));
+        // only messages of the mailbox get a value
+        const getValue = (message) => (context.isUid ? message.uid : numbers.get(message));
+        const current = new Set(matching);
+        const removed = [];
+        const added = [];
+        if (!context.compare) {
+            // a searching command, positions are 0 (RFC 5267 section 4.3.3)
+            context.results.forEach((message) => {
+                // a message that is gone without an EXPUNGE response for this session is just dropped
+                if (!current.has(message) && numbers.has(message)) {
+                    removed.push([0, getValue(message)]);
+                }
+            });
+            matching.forEach((message) => {
+                if (!context.results.has(message)) {
+                    added.push([0, getValue(message)]);
+                }
+            });
+        }
+        else {
+            // a sorting command. The sort values of a message do not change, so the results that stay keep their order.
+            // Removals are counted on the list as it shrinks, insertions in ascending order of their final position
+            let kept = 0;
+            context.order.forEach((message) => {
+                if (current.has(message)) {
+                    kept++;
+                }
+                else if (numbers.has(message)) {
+                    removed.push([kept + 1, getValue(message)]);
+                }
+            });
+            context.order = matching.sort(context.compare);
+            context.order.forEach((message, i) => {
+                if (!context.results.has(message)) {
+                    added.push([i + 1, getValue(message)]);
+                }
+            });
+        }
+        context.results = current;
+        if (removed.length || added.length) {
+            sendUpdate(connection, context, removed, added);
+        }
+    });
+};
+/**
+ * Removes expunged messages from the contexts that hold them, with one REMOVEFROM update per context
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Array} messages The expunged messages
+ * @param {Number} seq Sequence number of the EXPUNGE response for a single message, null when there is none (VANISHED)
+ */
+const removeExpunged = (connection, messages, seq) => {
+    connection.searchContexts.forEach((context) => {
+        if (context.mailbox !== connection.selectedMailbox) {
+            return;
+        }
+        const removed = [];
+        messages.forEach(message => {
+            if (!context.results.delete(message)) {
+                return;
+            }
+            let position = 0;
+            if (context.order) {
+                position = context.order.indexOf(message) + 1;
+                context.order.splice(position - 1, 1);
+            }
+            if (context.isUid || seq) {
+                removed.push([position, context.isUid ? message.uid : seq]);
+            }
+        });
+        if (removed.length) {
+            sendUpdate(connection, context, removed, []);
+        }
+    });
+};
+function contextSearchPlugin(server) {
+    // CONTEXT=SORT loads this plugin as well, so it may be called twice
+    if (server.addSearchContext) {
+        return;
+    }
+    // the result options of CONTEXT=SEARCH extend the extended SEARCH command (RFC 5267 section 4.1)
+    (0, esearch_js_1.default)(server);
+    server.registerCapability('CONTEXT=SEARCH');
+    const maxContexts = Math.max(Number(server.options.maxSearchContexts) || DEFAULT_MAX_CONTEXTS, 1);
+    // RFC 5267 section 4.2: the server MAY ignore the CONTEXT hint
+    server.searchReturnOptions.set('CONTEXT', { hint: true });
+    // RFC 5267 section 4.3: UPDATE has no data of its own, but the ESEARCH response is still sent
+    server.searchReturnOptions.set('UPDATE', { data: false, response: true, once: true });
+    // RFC 5267 section 4.4
+    (0, esearch_js_2.registerPartialOption)(server);
+    // RFC 5267 section 4.3: UPDATE with the tag of an earlier searching command that still has an updating
+    // context SHALL be rejected with BAD
+    server.searchReturnChecks.push((options, connection, parsed) => options.has('UPDATE') && getContexts(connection).has(parsed.tag) && 'Tag ' + parsed.tag + ' is already in use by an updating search');
+    /**
+     * Creates an updating context once a searching command with UPDATE has completed. Also used by
+     * CONTEXT=SORT and by the ESEARCH command of MULTISEARCH
+     *
+     * @param {Object} connection IMAP connection
+     * @param {Object} parsed Parsed searching command
+     * @param {String} data Raw command
+     * @param {Object} result Search result of the selected mailbox, with the `matches` function, and for a
+     *        sorting command the `sorted` list and the `compare` function
+     * @param {Boolean} isUid If true, the updates list UIDs
+     * @param {Object} [correlatorMailbox] Mailbox for the MAILBOX and UIDVALIDITY correlators (RFC 7377)
+     */
+    server.addSearchContext = (connection, parsed, data, result, isUid, correlatorMailbox) => {
+        const contexts = getContexts(connection);
+        if (contexts.size >= maxContexts) {
+            // RFC 5267 section 4.3.1: an untagged NO with NOUPDATE, the other result options are still honoured
+            connection.send({
+                tag: '*',
+                command: 'NO',
+                attributes: [
+                    {
+                        type: 'SECTION',
+                        section: [
+                            { type: 'ATOM', value: 'NOUPDATE' },
+                            { type: 'STRING', value: parsed.tag }
+                        ]
+                    },
+                    { type: 'TEXT', value: 'Too many updating contexts' }
+                ]
+            }, 'NOUPDATE', parsed, data);
+            return;
+        }
+        contexts.set(parsed.tag, {
+            tag: parsed.tag,
+            isUid,
+            matches: result.matches,
+            results: new Set(result.list),
+            compare: result.compare || null,
+            order: result.compare ? result.sorted.slice() : null,
+            mailbox: connection.selectedMailbox,
+            correlatorMailbox: correlatorMailbox || null
+        });
+    };
+    // RFC 5267 section 4.3.5: command-select =/ "CANCELUPDATE" 1*(SP quoted)
+    server.setCommandHandler('CANCELUPDATE', (connection, parsed, data, callback) => {
+        const tags = parsed.attributes || [];
+        if (!tags.length || tags.some(tag => !tag || tag.type !== 'STRING')) {
+            connection.sendStatus(parsed, data, 'BAD', 'CANCELUPDATE expects one or more quoted tags', false, 'CANCELUPDATE FAILED');
+            return callback();
+        }
+        const contexts = getContexts(connection);
+        const unknown = tags.find(tag => !contexts.has(tag.value));
+        if (unknown) {
+            // nothing is cancelled when a tag has no updating context
+            connection.sendStatus(parsed, data, 'NO', 'Unknown tag', false, 'CANCELUPDATE FAILED');
+            return callback();
+        }
+        tags.forEach(tag => contexts.delete(tag.value));
+        connection.sendStatus(parsed, data, 'OK', 'Updates cancelled', false, 'CANCELUPDATE');
+        return callback();
+    }, { states: command_states_js_1.states.SELECTED });
+    // UNAUTHENTICATE (RFC 8437) closes the mailbox, so the updates end
+    server.resetHandlers.push((connection) => {
+        connection.searchContexts = null;
+    });
+    server.connectionHandlers.push((connection) => {
+        // Notifications from other sessions (and this one) are flushed here. Once none are pending, the session
+        // knows the current message list, so new matches can be reported after their EXISTS and FETCH responses
+        // (RFC 5267 section 4.3.2). A command that closes the mailbox gets no updates, its tagged response ends them
+        const processNotifications = connection.processNotifications;
+        connection.processNotifications = function (data) {
+            processNotifications.call(this, data);
+            const command = ((data && data.command) || '').toUpperCase();
+            if (this.searchContexts && this.searchContexts.size && !this.notificationQueue.length && !CLOSING_COMMANDS.has(command)) {
+                checkContexts(this);
+            }
+        };
+    });
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        // RFC 5267 section 4.3.4: REMOVEFROM for an expunged message MUST be sent before the EXPUNGE response. After
+        // ENABLE QRESYNC a VANISHED response reports the expunged messages (RFC 7162 section 3.2.10), it has no sequence
+        // numbers, so contexts with sequence numbers drop those messages without an update
+        const expunged = response.tag === '*' && (response.message ? [response.message] : response.command === 'VANISHED' && response.messages);
+        if (expunged && connection.searchContexts) {
+            removeExpunged(connection, expunged, response.message ? response.attributes[0] : null);
+            return;
+        }
+        if (!parsed) {
+            return;
+        }
+        const command = (parsed.command || '').toUpperCase();
+        if (response.tag === parsed.tag && CLOSING_COMMANDS.has(command)) {
+            connection.searchContexts = null;
+            return;
+        }
+        if (!SEARCHING_COMMANDS.has(command) || !parsed.searchReturn || !parsed.searchReturn.has('UPDATE')) {
+            return;
+        }
+        // the full search result, the context is created when the command succeeded
+        if (response.tag === '*' && command.endsWith(String(response.command)) && description === command && extra && Array.isArray(extra.list)) {
+            parsed.contextResult = extra;
+            return;
+        }
+        if (response.tag === parsed.tag && response.command === 'OK' && parsed.contextResult) {
+            server.addSearchContext(connection, parsed, data, parsed.contextResult, command.startsWith('UID '));
+        }
+    });
+}
+{
+    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/context-sort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds CONTEXT=SORT [RFC5267] capability, loads ESORT and CONTEXT=SEARCH as well
+ * @help SORT RETURN (UPDATE) sends ADDTO and REMOVEFROM updates with context positions in sort order, PARTIAL and CONTEXT work for SORT too
+ */
+import type { IMAPServer } from '../types.js';
+export default function contextSortPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/context-sort.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @help Adds CONTEXT=SORT [RFC5267] capability, loads ESORT and CONTEXT=SEARCH as well
+ * @help SORT RETURN (UPDATE) sends ADDTO and REMOVEFROM updates with context positions in sort order, PARTIAL and CONTEXT work for SORT too
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = contextSortPlugin;
+const esort_js_1 = __importDefault(require("./esort.js"));
+const context_search_js_1 = __importDefault(require("./context-search.js"));
+function contextSortPlugin(server) {
+    // RFC 5267 section 4.1: CONTEXT=SORT means SORT and the extended SORT syntax of section 3. The updating
+    // contexts are shared with CONTEXT=SEARCH, so that is loaded (and advertised) as well
+    (0, esort_js_1.default)(server);
+    (0, context_search_js_1.default)(server);
+    server.registerCapability('CONTEXT=SORT');
+    server.contextSort = 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/create-special-use.d.ts

@@ -0,0 +1,7 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
+ * @help Allowed special flags can be set with server
+ * @help option "special-use"
+ */
+export default function createSpecialUsePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/create-special-use.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createSpecialUsePlugin;
+/**
+ * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
+ * @help Allowed special flags can be set with server
+ * @help option "special-use"
+ */
+function createSpecialUsePlugin(server) {
+    // Register capability
+    server.registerCapability('CREATE-SPECIAL-USE');
+    const createHandler = server.getCommandHandler('CREATE');
+    const allowedList = [].concat(server.options['special-use'] || ['\\Archive', '\\Drafts', '\\Flagged', '\\Junk', '\\Sent', '\\Trash']);
+    server.setCommandHandler('CREATE', (connection, parsed, data, callback) => {
+        let i;
+        let len;
+        let specialUseList;
+        const mailboxSpecialUse = [];
+        if (parsed.attributes && Array.isArray(parsed.attributes[1])) {
+            for (i = 0; i < parsed.attributes[1].length; i += 2) {
+                if (parsed.attributes[1][i] &&
+                    parsed.attributes[1][i].type === 'ATOM' &&
+                    parsed.attributes[1][i].value.toUpperCase() === 'USE' &&
+                    Array.isArray(parsed.attributes[1][i + 1])) {
+                    specialUseList = parsed.attributes[1][i + 1];
+                    parsed.attributes[1].splice(i, 2);
+                    i -= 2;
+                }
+            }
+            // Remove extra arguments if no members were left
+            if (!parsed.attributes[1].length) {
+                parsed.attributes.splice(1, 1);
+            }
+        }
+        if (specialUseList) {
+            for (i = 0, len = specialUseList.length; i < len; i++) {
+                if (['ATOM', 'STRING', 'LITERAL'].indexOf(specialUseList[i].type) < 0) {
+                    connection.send({
+                        tag: parsed.tag,
+                        command: 'BAD',
+                        attributes: [
+                            {
+                                type: 'TEXT',
+                                value: 'Invalid syntax for special use flag #' + (i + 1)
+                            }
+                        ]
+                    }, 'CREATE-SPECIAL-USE FAILED', parsed, data);
+                    return callback();
+                }
+                // attribute names are case-insensitive, store the canonical form
+                const specialUse = allowedList.find(value => value.toLowerCase() === String(specialUseList[i].value).toLowerCase());
+                if (!specialUse) {
+                    connection.send({
+                        tag: parsed.tag,
+                        command: 'NO',
+                        attributes: [
+                            {
+                                type: 'SECTION',
+                                section: [
+                                    {
+                                        type: 'ATOM',
+                                        value: 'USEATTR'
+                                    }
+                                ]
+                            },
+                            {
+                                type: 'TEXT',
+                                value: specialUseList[i].value + ' not supported'
+                            }
+                        ]
+                    }, 'CREATE-SPECIAL-USE FAILED', parsed, data);
+                    return callback();
+                }
+                if (mailboxSpecialUse.indexOf(specialUse) < 0) {
+                    mailboxSpecialUse.push(specialUse);
+                }
+            }
+        }
+        if (mailboxSpecialUse.length) {
+            parsed.mailboxSpecialUse = mailboxSpecialUse;
+        }
+        createHandler(connection, parsed, data, callback);
+    });
+    server.outputHandlers.push((connection, response, description, parsed, data, folder) => {
+        if (description === 'CREATE' && folder && parsed.mailboxSpecialUse) {
+            folder['special-use'] = parsed.mailboxSpecialUse;
+        }
+    });
+}
+{
+    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/enable.d.ts

@@ -0,0 +1,23 @@
+import type { IMAPConnection, IMAPServer } from '../types.js';
+/**
+ * @help Adds ENABLE capability [RFC5161]
+ * @help Plugins that can be enabled (eg. CONDSTORE)
+ * @help can be loaded in any order
+ */
+/**
+ * Makes an extension available for ENABLE. Plugins call it whether the ENABLE plugin is loaded before or after them
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {String} name Capability name in the spelling it is advertised in, e.g. "IMAP4rev2"
+ */
+declare function registerEnable(server: IMAPServer, name: string): void;
+/**
+ * Checks if a session has enabled an extension with ENABLE. UNAUTHENTICATE clears the list (RFC 8437 section 4.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Capability name in the spelling it was registered with, see registerEnable
+ * @return {Boolean} true if the extension is enabled
+ */
+declare function isEnabled(connection: IMAPConnection, name: string): boolean;
+export default function enablePlugin(server: IMAPServer): void;
+export { registerEnable, isEnabled };

package/dist/cjs/plugins/enable.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = enablePlugin;
+exports.registerEnable = registerEnable;
+exports.isEnabled = isEnabled;
+const command_states_js_1 = require("../command-states.js");
+/**
+ * @help Adds ENABLE capability [RFC5161]
+ * @help Plugins that can be enabled (eg. CONDSTORE)
+ * @help can be loaded in any order
+ */
+/**
+ * Makes an extension available for ENABLE. Plugins call it whether the ENABLE plugin is loaded before or after them
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {String} name Capability name in the spelling it is advertised in, e.g. "IMAP4rev2"
+ */
+function registerEnable(server, name) {
+    server.enableAvailable = server.enableAvailable || [];
+    if (server.enableAvailable.indexOf(name) < 0) {
+        server.enableAvailable.push(name);
+    }
+}
+/**
+ * Checks if a session has enabled an extension with ENABLE. UNAUTHENTICATE clears the list (RFC 8437 section 4.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Capability name in the spelling it was registered with, see registerEnable
+ * @return {Boolean} true if the extension is enabled
+ */
+function isEnabled(connection, name) {
+    return !!connection.enabled && connection.enabled.indexOf(name) >= 0;
+}
+function enablePlugin(server) {
+    server.registerCapability('ENABLE');
+    // Shared with plugins that can be enabled, these might be loaded before or after this one
+    server.enableAvailable = server.enableAvailable || [];
+    server.connectionHandlers.push((connection) => {
+        connection.enabled = connection.enabled || [];
+    });
+    // RFC 8437 section 4.1: extensions enabled with ENABLE cease to be enabled after UNAUTHENTICATE
+    server.resetHandlers.push((connection) => {
+        connection.enabled = [];
+    });
+    server.setCommandHandler('ENABLE', (connection, parsed, data, callback) => {
+        let capability;
+        let i;
+        let len;
+        // RFC 5161 section 3.1: "Clients MUST NOT issue ENABLE once they SELECT/EXAMINE a mailbox".
+        // Servers do not have to check this, ImapKit does to catch the client bug.
+        if (connection.everSelected) {
+            connection.sendStatus(parsed, data, 'BAD', 'ENABLE is not allowed after SELECT or EXAMINE');
+            return callback();
+        }
+        if (!parsed.attributes) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'ENABLE expects capability list'
+                    }
+                ]
+            }, 'INVALID COMMAND', parsed, data);
+            return callback();
+        }
+        for (i = 0, len = parsed.attributes.length; i < len; i++) {
+            if (!parsed.attributes[i] || parsed.attributes[i].type !== 'ATOM') {
+                connection.send({
+                    tag: parsed.tag,
+                    command: 'BAD',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'Attribute nr ' + (i + 1) + ' is not an ATOM'
+                        }
+                    ]
+                }, 'INVALID COMMAND', parsed, data);
+                return callback();
+            }
+        }
+        // The ENABLED response lists only the extensions enabled by this command
+        // Capability names are matched case-insensitively and listed in the spelling the server advertises them
+        // (`server.enableAvailable`), e.g. "IMAP4rev2", so plugins look them up in `connection.enabled` by that name
+        const enabled = [];
+        for (i = 0, len = parsed.attributes.length; i < len; i++) {
+            const requested = parsed.attributes[i].value.toUpperCase();
+            capability = server.enableAvailable.find((name) => name.toUpperCase() === requested);
+            if (capability && connection.enabled.indexOf(capability) < 0) {
+                connection.enabled.push(capability);
+                enabled.push(capability);
+            }
+        }
+        connection.send({
+            tag: '*',
+            command: 'ENABLED',
+            attributes: enabled.map(capability => ({
+                type: 'ATOM',
+                value: capability
+            }))
+        }, 'ENABLED', parsed, data, enabled);
+        connection.send({
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'ENABLE completed'
+                }
+            ]
+        }, 'ENABLE', parsed, data);
+        return callback();
+    }, { states: command_states_js_1.states.AUTHENTICATED });
+}
+{
+    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/esearch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds ESEARCH [RFC4731] capability
+ * @help SEARCH and UID SEARCH take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH
+ */
+import type { IMAPServer } from '../types.js';
+export default function esearchPlugin(server: IMAPServer): void;