imapkit 4.0.3 → 4.1.0

package/{lib → dist/esm}/plugins/esearch.js

@@ -1,38 +1,29 @@
-'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
  */
-
-const { buildEsearchResponse, selectReturned } = require('../esearch');
-const { badError } = require('../commands/handlers/search');
-
+import { buildEsearchResponse, selectReturned } from '../esearch.js';
+import { badError } from '../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 hasReturnOptions = (attributes) => {
     const first = attributes && attributes[0];
     return !!first && first.type === 'ATOM' && String(first.value).toUpperCase() === 'RETURN';
 };
-
-module.exports = function (server) {
+export default 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)
      *
@@ -46,7 +37,6 @@ module.exports = function (server) {
         if (!Array.isArray(list)) {
             throw 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();
@@ -67,7 +57,6 @@ module.exports = function (server) {
                 options.set(name, value);
             }
         }
-
         for (const check of server.searchReturnChecks) {
             const error = check(options, connection, parsed, names);
             if (error) {
@@ -76,44 +65,37 @@ module.exports = function (server) {
         }
         return options;
     };
-
     // only result options without return data, like SAVE (RFC 5182 section 1), suppress the ESEARCH response
-    server.isSilentReturn = options =>
-        options.size > 0 &&
+    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) {
+        }
+        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 => {
+    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 => {
+    server.connectionHandlers.push((connection) => {
         const usesSequenceNumbers = connection.usesSequenceNumbers;
         connection.usesSequenceNumbers = function (parsed) {
             if (hasReturnOptions(parsed.attributes)) {
@@ -122,35 +104,24 @@ module.exports = function (server) {
             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 ||
+        if (!parsed ||
             !parsed.searchReturn ||
             response.tag !== '*' ||
             response.command !== 'SEARCH' ||
             (description !== 'SEARCH' && description !== 'UID SEARCH') ||
             !extra ||
-            !Array.isArray(extra.list)
-        ) {
+            !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(
-            buildEsearchResponse(parsed.tag, description === 'UID SEARCH', extra, options),
-            'ESEARCH',
-            parsed,
-            data,
-            Object.assign({}, extra, { list: selectReturned(extra.list, options) })
-        );
+        connection.send(buildEsearchResponse(parsed.tag, description === 'UID SEARCH', extra, options), 'ESEARCH', parsed, data, Object.assign({}, extra, { list: selectReturned(extra.list, options) }));
     });
-};
+}

package/dist/esm/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/{lib → dist/esm}/plugins/esort.js

@@ -1,31 +1,22 @@
-'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
  */
-
-const sort = require('./sort');
-const esearch = require('./esearch');
-const { buildEsearchResponse, selectReturned } = require('../esearch');
-
-const isSort = command => command === 'SORT' || command === 'UID SORT';
-
-module.exports = function (server) {
+import sort from './sort.js';
+import esearch from './esearch.js';
+import { buildEsearchResponse, selectReturned } from '../esearch.js';
+const isSort = (command) => command === 'SORT' || command === 'UID SORT';
+export default function esortPlugin(server) {
     if (server.esortLoaded) {
         return;
     }
     server.esortLoaded = true;
-
     sort(server);
     esearch(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) => {
@@ -35,26 +26,17 @@ module.exports = function (server) {
         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(
-            buildEsearchResponse(parsed.tag, description === 'UID SORT', extra, options, null, extra.sorted),
-            'ESEARCH',
-            parsed,
-            data,
-            Object.assign({}, extra, { list: selectReturned(extra.sorted, options) })
-        );
+        connection.send(buildEsearchResponse(parsed.tag, description === 'UID SORT', extra, options, null, extra.sorted), 'ESEARCH', parsed, data, Object.assign({}, extra, { list: selectReturned(extra.sorted, options) }));
     });
-};
+}

package/dist/esm/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/esm/plugins/id.js

@@ -0,0 +1,108 @@
+import { states } from '../command-states.js';
+/**
+ * @help Adds ID [RFC2971] capability
+ */
+export default 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: 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();
+}

package/dist/esm/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/esm/plugins/idle.js

@@ -0,0 +1,70 @@
+import { states } from '../command-states.js';
+/**
+ * @help Adds IDLE [RFC2177] capability
+ */
+export default 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: states.AUTHENTICATED, noArguments: true });
+}

package/dist/esm/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/{lib → dist/esm}/plugins/imap4rev2.js

@@ -1,19 +1,14 @@
-'use strict';
-
-const { updateSession } = require('../utf8-session');
-const literalMinus = require('./literalminus');
-const { registerEnable, isEnabled } = require('./enable');
-
+import { updateSession } from '../utf8-session.js';
+import literalMinus from './literalminus.js';
+import { registerEnable, isEnabled } from './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']);
@@ -21,38 +16,30 @@ 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() : '');
-
-module.exports = function (server) {
-    // RFC 9051 Appendix A: advertised together with IMAP4rev1 (capability.js always lists it), so every session
+const isRev2 = (connection) => !!connection.imap4rev2;
+const atomName = (attr) => (attr && attr.type === 'ATOM' ? String(attr.value).toUpperCase() : '');
+export default 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');
-
     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-']) {
         literalMinus(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 setMode = (connection) => {
         const rev2 = (connection.imap4rev2 = 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)
         updateSession(connection);
@@ -66,8 +53,9 @@ module.exports = function (server) {
         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 {
+            connection.getFlags = (message) => message.flags;
+        }
+        else {
             // back to IMAPConnection#getFlags
             delete connection.getFlags;
         }
@@ -75,18 +63,15 @@ module.exports = function (server) {
     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]) => {
@@ -97,25 +82,17 @@ module.exports = function (server) {
             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)'
-            );
+            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) => {
@@ -126,33 +103,24 @@ module.exports = function (server) {
     };
     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
-        );
+        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;
@@ -161,29 +129,25 @@ module.exports = function (server) {
         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
-module.exports.requires = [
+imap4rev2Plugin.requires = [
     'ENABLE',
     'NAMESPACE',
     'UNSELECT',

package/dist/esm/plugins/index.d.ts

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