imapkit 4.0.3 → 4.1.1

package/dist/cjs/commands/rename.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = renameCommand;
+function renameCommand(connection, parsed, data, callback) {
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'RENAME expects mailbox source and destination names'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const source = parsed.attributes[0].value;
+    const destination = parsed.attributes[1].value;
+    const server = connection.server;
+    const mailbox = server.getMailbox(source);
+    const target = server.getMailbox(destination);
+    const sendError = (code, message) => {
+        connection.sendStatus(parsed, data, 'NO', message, code, 'RENAME FAILED');
+        return callback();
+    };
+    // check everything that can be checked up front, so that a failed RENAME never loses the source
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        return sendError('NONEXISTENT', 'Mailbox does not exist');
+    }
+    if (target && target.flags.indexOf('\\Noselect') < 0) {
+        return sendError('ALREADYEXISTS', 'Mailbox already exists');
+    }
+    const separator = server.getSeparator(mailbox);
+    if (destination.substr(0, mailbox.path.length + separator.length) === mailbox.path + separator) {
+        return sendError('CANNOT', 'Can not move a mailbox into itself');
+    }
+    const oldPath = mailbox.path;
+    let newPath;
+    try {
+        if (source.toUpperCase() === 'INBOX') {
+            // Renaming INBOX moves its messages to the new mailbox and leaves INBOX empty (RFC 3501 section 6.3.5)
+            const newMailbox = server.createMailbox(destination);
+            newPath = newMailbox.path;
+            mailbox.messages.forEach((message) => {
+                server.copyMessage(newMailbox, message);
+            });
+            connection.expungeSpecificMessages(mailbox, () => true);
+        }
+        else {
+            server.deleteMailbox(source, true);
+            try {
+                server.createMailbox(destination, mailbox);
+            }
+            catch (E) {
+                // put the source mailbox back where it was
+                server.createMailbox(source, mailbox);
+                server.indexFolders();
+                throw E;
+            }
+            server.indexFolders();
+            newPath = mailbox.path;
+        }
+    }
+    catch (err) {
+        const E = err;
+        return sendError(E.code, E.message);
+    }
+    server.mailboxChanged('rename', newPath, { oldPath });
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'RENAME completed'
+            }
+        ]
+    }, 'RENAME', parsed, data, mailbox);
+    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/commands/search.d.ts

@@ -0,0 +1,10 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+/**
+ * Shared implementation of SEARCH and UID SEARCH
+ *
+ * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
+ */
+declare function processSearch(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const searchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default searchCommand;
+export { processSearch };

package/dist/cjs/commands/search.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSearch = processSearch;
+const search_js_1 = __importDefault(require("./handlers/search.js"));
+const search_js_2 = require("./handlers/search.js");
+/**
+ * Shared implementation of SEARCH and UID SEARCH
+ *
+ * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
+ */
+function processSearch(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID SEARCH' : 'SEARCH';
+    if (!parsed.attributes || !parsed.attributes.length) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects search criteria, empty query given'
+                }
+            ]
+        }, command + ' FAILED', parsed, data);
+        return callback();
+    }
+    let searchResult;
+    try {
+        searchResult = (0, search_js_1.default)(connection, connection.getSessionMessages(), (0, search_js_2.criteriaValues)(parsed.attributes));
+    }
+    catch (E) {
+        (0, search_js_2.sendSearchError)(connection, parsed, data, E, command + ' FAILED');
+        return callback();
+    }
+    // RFC 3501 7.2.5: the SEARCH response is sent even when nothing matched. Plugins get the
+    // search result, so they can extend the response or replace it (e.g. ESEARCH)
+    connection.send({
+        tag: '*',
+        command: 'SEARCH',
+        attributes: searchResult.list.map(item => {
+            return isUid ? item.uid : searchResult.numbers[item.uid];
+        })
+    }, command, parsed, data, searchResult);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' completed'
+            }
+        ]
+    }, command, parsed, data);
+    return callback();
+}
+const searchCommand = (connection, parsed, data, callback) => processSearch(false, connection, parsed, data, callback);
+exports.default = searchCommand;
+{
+    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/commands/select.d.ts

@@ -0,0 +1,19 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function selectCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+/**
+ * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
+ * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
+ * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ */
+declare function beginSelect(connection: IMAPConnection, parsed: ParsedCommand, data: string): void;
+/**
+ * Shared implementation of SELECT and EXAMINE
+ *
+ * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
+ */
+declare function selectMailbox(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback, readOnly: boolean): void;
+export { selectMailbox, beginSelect };

package/dist/cjs/commands/select.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = selectCommand;
+exports.selectMailbox = selectMailbox;
+exports.beginSelect = beginSelect;
+function selectCommand(connection, parsed, data, callback) {
+    return selectMailbox(connection, parsed, data, callback, false);
+}
+/**
+ * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
+ * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
+ * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ */
+function beginSelect(connection, parsed, data) {
+    connection.everSelected = true;
+    if (connection.state === 'Selected' && connection.server.closedChecks.some(check => check(connection))) {
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                { type: 'SECTION', section: [{ type: 'ATOM', value: 'CLOSED' }] },
+                { type: 'TEXT', value: 'Previous mailbox closed' }
+            ]
+        }, 'CLOSED', parsed, data);
+    }
+}
+/**
+ * Shared implementation of SELECT and EXAMINE
+ *
+ * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
+ */
+function selectMailbox(connection, parsed, data, callback, readOnly) {
+    const command = readOnly ? 'EXAMINE' : 'SELECT';
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects 1 mailbox argument'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    beginSelect(connection, parsed, data);
+    const mailbox = connection.server.getMailbox(path);
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        // a failed SELECT leaves no mailbox selected (RFC 3501 section 6.3.1)
+        connection.closeMailbox();
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', command + ' FAILED');
+        return callback();
+    }
+    connection.state = 'Selected';
+    connection.selectedMailbox = mailbox;
+    connection.readOnly = readOnly;
+    connection.notificationQueue = [];
+    // \Recent is a session flag: a read-write session takes over the messages
+    // that no other session has seen yet (RFC 3501 section 2.3.2)
+    const recent = new Set();
+    connection.recent = recent;
+    mailbox.messages.forEach((message) => {
+        if (message.recent) {
+            recent.add(message);
+            if (!readOnly) {
+                delete message.recent;
+            }
+        }
+    });
+    const status = connection.server.getStatus(mailbox);
+    const permanentFlags = status.permanentFlags.map((flag) => {
+        return {
+            type: 'ATOM',
+            value: flag
+        };
+    });
+    connection.send({
+        tag: '*',
+        command: 'FLAGS',
+        attributes: [permanentFlags]
+    }, command + ' FLAGS', parsed, data);
+    if (mailbox.allowPermanentFlags) {
+        permanentFlags.push({
+            type: 'TEXT',
+            value: '\\*'
+        });
+    }
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'PERMANENTFLAGS'
+                    },
+                    // nothing can be changed in a read-only mailbox
+                    readOnly ? [] : permanentFlags
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: readOnly ? 'No permanent flags permitted' : 'Flags permitted'
+            }
+        ]
+    }, command + ' PERMANENTFLAGS', parsed, data);
+    connection.send({
+        tag: '*',
+        attributes: [
+            mailbox.messages.length,
+            {
+                type: 'ATOM',
+                value: 'EXISTS'
+            }
+        ]
+    }, command + ' EXISTS', parsed, data);
+    connection.send({
+        tag: '*',
+        attributes: [
+            connection.recent.size,
+            {
+                type: 'ATOM',
+                value: 'RECENT'
+            }
+        ]
+    }, command + ' RECENT', parsed, data);
+    const firstUnseen = mailbox.messages.findIndex((message) => message.flags.indexOf('\\Seen') < 0);
+    if (firstUnseen >= 0) {
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'UNSEEN'
+                        },
+                        firstUnseen + 1
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'First unseen message'
+                }
+            ]
+        }, command + ' UNSEEN', parsed, data);
+    }
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'UIDVALIDITY'
+                    },
+                    mailbox.uidvalidity
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'UIDs valid'
+            }
+        ]
+    }, command + ' UIDVALIDITY', parsed, data);
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'UIDNEXT'
+                    },
+                    mailbox.uidnext
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'Predicted next UID'
+            }
+        ]
+    }, command + ' UIDNEXT', parsed, data);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: readOnly ? 'READ-ONLY' : 'READ-WRITE'
+                    }
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 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/commands/status.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function statusCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/status.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = statusCommand;
+const status_js_1 = require("./handlers/status.js");
+function statusCommand(connection, parsed, data, callback) {
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !Array.isArray(parsed.attributes[1]) ||
+        !parsed.attributes[1].length) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'STATUS expects mailbox argument and a list of status items'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    // invalid arguments are BAD even for a mailbox that does not exist
+    let items;
+    try {
+        items = (0, status_js_1.parseStatusItems)(connection.server, parsed.attributes[1], connection);
+    }
+    catch (err) {
+        connection.sendStatus(parsed, data, 'BAD', err.message, false, 'STATUS FAILED');
+        return callback();
+    }
+    const mailbox = connection.server.getMailbox(path);
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'STATUS FAILED');
+        return callback();
+    }
+    (0, status_js_1.sendStatus)(connection, path, mailbox, items, parsed, data);
+    // RFC 3501 section 6.3.10 and RFC 9051 section 6.3.11: STATUS SHOULD NOT be used on the selected mailbox. It
+    // works, but the client gets the CLIENTBUG response code (RFC 5530 section 3) like RFC 9051 section 7.1 shows
+    const clientBug = connection.state === 'Selected' && connection.selectedMailbox === mailbox;
+    connection.sendStatus(parsed, data, 'OK', clientBug ? 'Status completed, STATUS SHOULD NOT be used on the selected mailbox' : 'Status completed', clientBug && 'CLIENTBUG');
+    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/commands/store.d.ts

@@ -0,0 +1,10 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+/**
+ * Shared implementation of STORE and UID STORE
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs
+ */
+declare function processStore(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const storeCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default storeCommand;
+export { processStore };

package/dist/cjs/commands/store.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStore = processStore;
+const store_js_1 = __importDefault(require("./handlers/store.js"));
+const arguments_js_1 = require("../arguments.js");
+/**
+ * Returns the handler of a STORE data item, plugins first
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Data item name, e.g. "+FLAGS.SILENT"
+ * @return {Function|undefined} handler
+ */
+function getStoreHandler(connection, name) {
+    name = String(name).toUpperCase();
+    return connection.server.storeHandlers[name] || store_js_1.default[name];
+}
+/**
+ * Shared implementation of STORE and UID STORE
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs
+ */
+function processStore(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID STORE' : 'STORE';
+    // a store handler with `astringValues` takes astrings, like the labels of X-GM-LABELS: these can be literals,
+    // and NIL is a name there. Flags are atoms (RFC 3501 section 9: flag-list)
+    const itemArgument = parsed.attributes && parsed.attributes[1];
+    const itemHandler = (0, arguments_js_1.isAtom)(itemArgument) && getStoreHandler(connection, itemArgument.value);
+    const astringValues = !!(itemHandler && itemHandler.astringValues);
+    const valueTypes = astringValues ? ['ATOM', 'STRING', 'LITERAL'] : ['ATOM', 'STRING'];
+    if (astringValues) {
+        (0, arguments_js_1.restoreNilAtoms)(parsed, data, (path) => path[0] === 2);
+    }
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 3 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['ATOM'].indexOf(parsed.attributes[1].type) < 0 ||
+        !parsed.attributes[2] ||
+        !(valueTypes.indexOf(parsed.attributes[2].type) >= 0 || Array.isArray(parsed.attributes[2]))) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set, item name and item value'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    // A mailbox opened with EXAMINE is read-only (RFC 3501 6.3.2), so its flags can not be changed
+    if (connection.refuseReadOnly(parsed, data, command + ' FAILED')) {
+        return callback();
+    }
+    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
+    const itemName = (parsed.attributes[1].value || '').toUpperCase();
+    const itemValue = [].concat(parsed.attributes[2] || []);
+    const affected = [];
+    // if the sequence set includes a message that another session expunged without this session being told yet
+    let hasExpunged = false;
+    try {
+        itemValue.forEach((item, i) => {
+            if (!item || valueTypes.indexOf(item.type) < 0) {
+                throw new Error('Invalid item value #' + (i + 1));
+            }
+        });
+        const handler = itemHandler || getStoreHandler(connection, itemName);
+        if (!handler) {
+            throw new Error('Invalid STORE argument ' + itemName);
+        }
+        range.forEach(rangeMessage => {
+            if (rangeMessage[1].ghost) {
+                // RFC 2180 section 4.2: the flags of an expunged message are not stored
+                hasExpunged = true;
+                return;
+            }
+            for (let i = 0, len = connection.server.storeFilters.length; i < len; i++) {
+                if (!connection.server.storeFilters[i](connection, rangeMessage[1], parsed, rangeMessage[0])) {
+                    return;
+                }
+            }
+            handler(connection, rangeMessage[1], itemValue, rangeMessage[0], parsed, data);
+            affected.push(rangeMessage[1]);
+        });
+    }
+    catch (err) {
+        const E = err;
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: E.message
+                }
+            ]
+        }, command + ' FAILED', parsed, data);
+        return callback();
+    }
+    // RFC 2180 sections 4.2.2 and 4.2.3: when the set includes expunged messages, the others are stored and get
+    // their FETCH responses, and the tagged NO tells the client to issue NOOP. With .SILENT the result is OK as
+    // long as the other messages were stored (section 4.2.1)
+    const failed = hasExpunged && !/\.SILENT$/.test(itemName);
+    connection.send({
+        tag: parsed.tag,
+        command: failed ? 'NO' : 'OK',
+        attributes: [].concat(failed ? { type: 'SECTION', section: [{ type: 'ATOM', value: 'EXPUNGEISSUED' }] } : [], {
+            type: 'TEXT',
+            value: failed ? 'Some of the messages no longer exist' : command + ' completed'
+        })
+    }, command + (failed ? ' FAILED' : ' COMPLETE'), parsed, data, affected);
+    // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
+    connection.notifyFlagChanges(affected);
+    callback();
+}
+const storeCommand = (connection, parsed, data, callback) => processStore(false, connection, parsed, data, callback);
+exports.default = storeCommand;
+{
+    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/commands/subscribe.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function subscribeCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;