imapkit 4.0.3 → 4.1.0

package/dist/cjs/commands/append.js

@@ -0,0 +1,299 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.badArgument = void 0;
+exports.default = appendCommand;
+exports.appendError = appendError;
+exports.prepareAppend = prepareAppend;
+exports.storeMessages = storeMessages;
+exports.getPendingTarget = getPendingTarget;
+exports.refuseMissingTarget = refuseMissingTarget;
+const imap_handler_1 = __importDefault(require("imap-handler"));
+const flags_js_1 = require("./handlers/flags.js");
+const arguments_js_1 = require("../arguments.js");
+/**
+ * Creates an error that refuses an APPEND like command
+ *
+ * @param {String} text Human readable text
+ * @param {String} [code] Response code, e.g. "TOOBIG"
+ * @param {Array} [codeArgs] Arguments of the response code, as response attributes
+ * @param {String} [response] "NO" (default) or "BAD"
+ * @return {Error} Error object
+ */
+function appendError(text, code, codeArgs, response) {
+    const err = new Error(text);
+    err.imapResponse = response || 'NO';
+    err.responseCode = code || false;
+    err.responseCodeArgs = codeArgs || [];
+    return err;
+}
+const badArgument = (text) => appendError(text, false, false, 'BAD');
+exports.badArgument = badArgument;
+/**
+ * Parses a flag list, flags are atoms, and \Recent or unknown system flags can not be set (RFC 3501 section 9)
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Array} list Parsed flag list
+ * @return {Array} Flags
+ */
+function parseFlags(connection, list) {
+    try {
+        return list.map(flag => {
+            if (!flag || flag.type !== 'ATOM') {
+                throw new Error('Invalid flags argument');
+            }
+            const value = (0, flags_js_1.normalizeSystemFlag)(flag.value);
+            (0, flags_js_1.checkSystemFlags)(connection, value);
+            return value;
+        });
+    }
+    catch {
+        throw badArgument('Invalid flags argument');
+    }
+}
+/**
+ * Parses the messages of an APPEND like command. RFC 3502 and RFC 4466 section 3:
+ * append-message = [SP flag-list] [SP date-time] SP append-data, where append-data is a literal
+ * or an extension (label SP value) from `server.appendDataHandlers`, e.g. CATENATE (RFC 4469)
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Array} args Parsed arguments after the mailbox name
+ * @param {Number} maxMessages Largest number of messages allowed
+ * @return {Array} Messages `{ flags, internaldate, raw, resolve, literal8 }`, resolve builds the message source
+ *   of an append-data extension. Throws a BAD error if the arguments break the grammar
+ */
+function parseMessages(connection, args, maxMessages) {
+    const server = connection.server;
+    const messages = [];
+    for (let i = 0; i < args.length;) {
+        const message = { flags: [], internaldate: false, raw: false };
+        if (Array.isArray(args[i])) {
+            message.flags = parseFlags(connection, args[i++]);
+        }
+        // date-time is always a quoted string, a literal here is the message
+        if (args[i] && args[i].type === 'STRING') {
+            if (!server.validateInternalDate(args[i].value)) {
+                throw badArgument('Invalid internaldate argument');
+            }
+            message.internaldate = args[i++].value;
+        }
+        const appendData = args[i++];
+        const label = appendData && appendData.type === 'ATOM' ? String(appendData.value).toUpperCase() : '';
+        if (appendData && appendData.type === 'LITERAL') {
+            message.raw = appendData.value;
+        }
+        else if (appendData && appendData.type === 'LITERAL8' && server.appendLiteral8) {
+            // RFC 3516 section 4.4: the message as a literal8, server.appendLiteral8 (BINARY) stores it
+            message.raw = appendData.value;
+            message.literal8 = true;
+        }
+        else if (label && Object.hasOwn(server.appendDataHandlers, label) && i < args.length) {
+            message.resolve = server.appendDataHandlers[label](connection, args[i++]);
+        }
+        else {
+            throw badArgument('Invalid message source argument');
+        }
+        messages.push(message);
+    }
+    if (!messages.length) {
+        throw badArgument('Missing message argument');
+    }
+    if (messages.length > maxMessages) {
+        // only a single message unless MULTIAPPEND is supported (RFC 4466 section 3)
+        throw badArgument('Only a single message can be appended');
+    }
+    return messages;
+}
+/**
+ * Sends the response for an error from appendError()
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Error} err Error object
+ * @param {String} description Description of a NO response
+ */
+function sendAppendError(connection, parsed, data, err, description) {
+    const attributes = [];
+    if (err.responseCode) {
+        attributes.push({
+            type: 'SECTION',
+            section: [{ type: 'ATOM', value: err.responseCode }].concat(err.responseCodeArgs)
+        });
+    }
+    attributes.push({ type: 'TEXT', value: err.message });
+    connection.send({
+        tag: parsed.tag,
+        command: err.imapResponse,
+        attributes
+    }, err.imapResponse === 'BAD' ? 'INVALID COMMAND' : description, parsed, data);
+}
+/**
+ * Finds the target mailbox name of an APPEND or REPLACE command when a literal of a message (or of a CATENATE TEXT
+ * part) is announced. Only the start of the command up to the mailbox argument is parsed, so the data of earlier
+ * literals is not parsed again for every message of a MULTIAPPEND
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {String|Boolean} storage name of the mailbox, or false if the literal is not a message or the name is not
+ *   known yet or not valid
+ */
+function getPendingTarget(connection, command, line) {
+    const options = connection.server.getCommandOptions(command);
+    if (!options.appendMessage) {
+        return false;
+    }
+    const mailboxPosition = options.mailboxArguments[0];
+    // the literal of a CATENATE URL is not a message part
+    if (/[ (]URL $/i.test(line.slice(-5))) {
+        return false;
+    }
+    // an open CATENATE list is closed for parsing
+    const parse = (text) => {
+        text = text.replace(/ $/, '');
+        for (const suffix of ['', ')']) {
+            try {
+                const parsed = imap_handler_1.default.parser(text + suffix);
+                (0, arguments_js_1.restoreNilAtoms)(parsed, text, (path) => path.length === 1 && path[0] === mailboxPosition);
+                return parsed.attributes || [];
+            }
+            catch {
+                // try the next suffix
+            }
+        }
+        return [];
+    };
+    // the command up to the first literal, or up to the end of it when that literal is the mailbox name
+    const literal = line.match(/(~?)\{(\d+)\+?\}\r\n/);
+    let attributes = parse(literal ? line.substr(0, literal.index) : line);
+    if (attributes.length <= mailboxPosition && literal && !literal[1]) {
+        attributes = parse(line.substr(0, literal.index + literal[0].length + Number(literal[2])));
+    }
+    // a literal8 can not be a mailbox name, the command handler refuses it
+    const pathArg = attributes[mailboxPosition];
+    if (!(0, arguments_js_1.isAstring)(pathArg)) {
+        return false;
+    }
+    try {
+        return connection.importMailboxName(pathArg.value);
+    }
+    catch {
+        // the command handler refuses the name
+        return false;
+    }
+}
+/**
+ * A literal filter (`server.literalFilters`) that refuses the message of an APPEND or REPLACE to a mailbox that does
+ * not exist before the client sends it, by not sending a continuation request (RFC 3502 section 6.3.11 example A004,
+ * RFC 3501 section 6.3.11: TRYCREATE). Not while earlier commands are still waiting, these could create the mailbox
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {Object|Boolean} `{ command, code, text }` to refuse the literal, or false
+ */
+function refuseMissingTarget(connection, command, line) {
+    const path = !connection.isBusy() && getPendingTarget(connection, command, line);
+    return path !== false && connection.server.targetRefusal(path);
+}
+/**
+ * Prepares the messages of an APPEND like command (APPEND, REPLACE): parses the arguments, checks
+ * the target mailbox, builds the message sources and runs `server.appendChecks` through
+ * IMAPConnection#checkAppend. Nothing is stored yet, so a failure leaves every mailbox as it was
+ * (RFC 3502 section 6.3.11). The error response is sent here.
+ *
+ * The checks get the built messages (with `raw`) of the whole command and the options as
+ * `{ command, replaced }`, `replaced` is the message that REPLACE removes.
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Object} pathArg Parsed mailbox name argument
+ * @param {Array} args Parsed arguments after the mailbox name
+ * @param {Object} options `{ command, maxMessages, replaced }`
+ * @return {Object|Boolean} `{ mailbox, messages }` or false if an error response was sent
+ */
+function prepareAppend(connection, parsed, data, pathArg, args, options) {
+    const description = options.command + ' FAILED';
+    const maxMessages = options.maxMessages || (connection.server.multiAppend ? Infinity : 1);
+    try {
+        if (!pathArg || ['STRING', 'ATOM', 'LITERAL'].indexOf(pathArg.type) < 0) {
+            throw badArgument('Invalid mailbox argument');
+        }
+        const messages = parseMessages(connection, args, maxMessages);
+        // getTargetMailbox sends the NO response itself
+        const mailbox = connection.getTargetMailbox(pathArg.value, parsed, data, description);
+        if (!mailbox) {
+            return false;
+        }
+        messages.forEach(message => {
+            if (message.resolve) {
+                message.raw = message.resolve();
+            }
+            else if (message.literal8) {
+                // literal8 is only set when server.appendLiteral8 exists, and then raw holds the literal
+                message.raw = connection.server.appendLiteral8(message.raw);
+            }
+        });
+        // every message source is built now
+        const prepared = messages;
+        // checkAppend sends the NO response itself
+        if (!connection.checkAppend(mailbox, prepared, parsed, data, description, { command: options.command, replaced: options.replaced })) {
+            return false;
+        }
+        return { mailbox, messages: prepared };
+    }
+    catch (error) {
+        const err = error;
+        if (!err.imapResponse) {
+            throw err;
+        }
+        sendAppendError(connection, parsed, data, err, description);
+        return false;
+    }
+}
+/**
+ * Stores prepared messages. The sessions that have the target mailbox selected get EXISTS updates
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} prepared Result of prepareAppend()
+ * @return {Object} `{ mailbox, message, messages }`, message is the last stored message
+ */
+function storeMessages(connection, prepared) {
+    const messages = prepared.messages.map(message => connection.server.appendMessage(prepared.mailbox, message.flags, message.internaldate, message.raw).message);
+    return { mailbox: prepared.mailbox, message: messages[messages.length - 1], messages };
+}
+function appendCommand(connection, parsed, data, callback) {
+    const args = [].concat(parsed.attributes || []);
+    const prepared = prepareAppend(connection, parsed, data, args.shift(), args, { command: 'APPEND' });
+    if (!prepared) {
+        return callback();
+    }
+    const appendResult = storeMessages(connection, prepared);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'APPEND Completed'
+            }
+        ]
+    }, 'APPEND', parsed, data, appendResult);
+    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/capability.d.ts

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

package/dist/cjs/commands/capability.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = capabilityCommand;
+function capabilityCommand(connection, parsed, data, callback) {
+    const capabilities = ['IMAP4rev1'];
+    Object.keys(connection.server.capabilities).forEach(key => {
+        if (connection.server.capabilities[key](connection)) {
+            capabilities.push(key);
+        }
+    });
+    connection.send({
+        tag: '*',
+        command: 'CAPABILITY',
+        attributes: capabilities.map(capability => {
+            return {
+                type: 'TEXT',
+                value: capability
+            };
+        })
+    }, 'CAPABILITY LIST', parsed, data, capabilities);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'CAPABILITY COMPLETED', parsed, data, capabilities);
+    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/check.d.ts

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

package/dist/cjs/commands/check.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkCommand;
+function checkCommand(connection, parsed, data, callback) {
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'CHECK', parsed, data);
+    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/close.d.ts

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

package/dist/cjs/commands/close.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = closeCommand;
+function closeCommand(connection, parsed, data, callback) {
+    // a read-only mailbox is closed without removing anything
+    if (connection.canExpunge()) {
+        connection.expungeDeleted(connection.selectedMailbox, true);
+    }
+    // CLOSE does not send pending EXPUNGE or EXISTS responses (RFC 3501 section 6.4.2)
+    connection.notificationQueue = [];
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Mailbox closed'
+            }
+        ]
+    }, 'CLOSE', parsed, data);
+    connection.closeMailbox();
+    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/copy.d.ts

@@ -0,0 +1,30 @@
+import type { Callback, IMAPConnection, Mailbox, Message, ParsedCommand } from '../types.js';
+/** The result of copyToMailbox(), the extra context of the tagged OK (UIDPLUS) */
+export interface CopyResult {
+    mailbox: Mailbox;
+    sourceUids: number[];
+    targetUids: number[];
+    /** the copied source messages */
+    messages: Message[];
+}
+export default function copyCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+/**
+ * Shared implementation of COPY and UID COPY
+ *
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ */
+declare function copyMessages(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback, isUid: boolean): void;
+/**
+ * Copies messages from the selected mailbox to another one, the copy step of COPY and MOVE.
+ * Sends a tagged NO and returns false if the target mailbox can not be used.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command, with the sequence set and the mailbox name as arguments
+ * @param {String} data Raw command
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ * @param {String} failDescription Description for the failure response
+ * @param {Boolean} [isMove] If true, the messages are moved, the caller expunges them afterwards
+ * @return {Object|false} `{ mailbox, sourceUids, targetUids, messages }`, where messages lists the copied source messages
+ */
+declare function copyToMailbox(connection: IMAPConnection, parsed: ParsedCommand, data: string, isUid: boolean, failDescription: string, isMove?: boolean): CopyResult | false;
+export { copyMessages, copyToMailbox };

package/dist/cjs/commands/copy.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = copyCommand;
+exports.copyMessages = copyMessages;
+exports.copyToMailbox = copyToMailbox;
+function copyCommand(connection, parsed, data, callback) {
+    return copyMessages(connection, parsed, data, callback, false);
+}
+/**
+ * Shared implementation of COPY and UID COPY
+ *
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ */
+function copyMessages(connection, parsed, data, callback, isUid) {
+    const command = isUid ? 'UID COPY' : 'COPY';
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['ATOM', 'STRING', 'LITERAL'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set and a mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const result = copyToMailbox(connection, parsed, data, isUid, command + ' FAIL');
+    if (!result) {
+        return callback();
+    }
+    // the result is the extra context info for UIDPLUS
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' Completed'
+            }
+        ]
+    }, command, parsed, data, result);
+    callback();
+}
+/**
+ * Copies messages from the selected mailbox to another one, the copy step of COPY and MOVE.
+ * Sends a tagged NO and returns false if the target mailbox can not be used.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command, with the sequence set and the mailbox name as arguments
+ * @param {String} data Raw command
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ * @param {String} failDescription Description for the failure response
+ * @param {Boolean} [isMove] If true, the messages are moved, the caller expunges them afterwards
+ * @return {Object|false} `{ mailbox, sourceUids, targetUids, messages }`, where messages lists the copied source messages
+ */
+function copyToMailbox(connection, parsed, data, isUid, failDescription, isMove) {
+    // the command handler checked the arguments
+    const attributes = parsed.attributes;
+    const range = connection.limitRange(parsed, connection.getCommandRange(attributes[0].value, isUid));
+    const mailbox = connection.getTargetMailbox(attributes[1].value, parsed, data, failDescription);
+    if (!mailbox) {
+        return false;
+    }
+    const messages = range.map(rangeMessage => rangeMessage[1]);
+    if (messages.some((message) => message.ghost)) {
+        // RFC 2180 section 4.4.1: nothing is copied when the set includes a message that another session expunged,
+        // the pending EXPUNGE responses go out before the NO
+        connection.sendStatus(parsed, data, 'NO', 'Some of the requested messages no longer exist', 'EXPUNGEISSUED', failDescription);
+        return false;
+    }
+    if (!connection.checkAppend(mailbox, messages, parsed, data, failDescription, { move: !!isMove, source: connection.selectedMailbox })) {
+        return false;
+    }
+    const sourceUids = [];
+    const targetUids = [];
+    // a range that is processed from the highest UID down (parsed.highestFirst) is still copied in UID order,
+    // so the new UIDs follow the order of the source UIDs (RFC 9738 section 3.1 MOVE example)
+    (parsed.highestFirst ? messages.slice().reverse() : messages).forEach((message) => {
+        sourceUids.push(message.uid);
+        targetUids.push(connection.server.copyMessage(mailbox, message).message.uid);
+    });
+    return {
+        mailbox,
+        sourceUids,
+        targetUids,
+        messages
+    };
+}
+{
+    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/create.d.ts

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

package/dist/cjs/commands/create.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createCommand;
+function createCommand(connection, parsed, data, callback) {
+    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: 'CREATE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    let mailbox;
+    try {
+        mailbox = connection.server.createMailbox(path);
+    }
+    catch (err) {
+        const E = err;
+        // RFC 5530 response codes, e.g. [ALREADYEXISTS]
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'CREATE FAILED');
+        return callback();
+    }
+    connection.server.mailboxChanged('create', mailbox.path);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'CREATE completed'
+            }
+        ]
+    }, 'CREATE', 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/delete.d.ts

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