imapflow 1.7.8 → 2.0.1

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Public data shapes of the ImapFlow API. Every optional property is declared with an
+// explicit `| undefined` so that a consumer compiling with exactOptionalPropertyTypes
+// can still pass a value that may be undefined.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/charsets.d.ts

@@ -0,0 +1 @@
+export declare const resolveCharset: (charset: string) => string | null;

package/{lib → dist/esm}/charsets.js

@@ -1,5 +1,3 @@
-'use strict';
-
 // Subset of the IANA Character Sets registry (https://www.iana.org/assignments/character-sets/).
 // Used to validate and resolve charset names found in MIME Content-Type parameters.
 // This list covers the most commonly encountered charsets in email messages.
@@ -262,9 +260,7 @@ const CHARACTER_SETS = [
     'TIS-620',
     'CP50220'
 ];
-
 const CHARSET_MAP = new Map();
-
 // Build a lookup map with normalized keys for fuzzy charset resolution.
 // Normalization strategy:
 // 1. Strip all underscores, hyphens, and spaces, then lowercase (e.g., "ISO-8859-1" -> "iso88591")
@@ -284,12 +280,11 @@ CHARACTER_SETS.forEach(entry => {
         CHARSET_MAP.set(modifiedKey, entry);
     }
 });
-
 // Resolves a charset name to its canonical IANA form using case-insensitive,
 // symbol-stripping normalization. For example, "WIN-1252", "windows_1252",
 // and "WINDOWS-1252" all resolve to "windows-1252".
 // Returns null if the charset is not recognized.
-module.exports.resolveCharset = charset => {
+export const resolveCharset = (charset) => {
     let key = charset.replace(/[_-\s]/g, '').toLowerCase();
     return CHARSET_MAP.get(key) ?? null;
 };

package/dist/esm/commands/append.d.ts

@@ -0,0 +1,22 @@
+import type { ImapFlow } from '../imap-flow.js';
+import type { AppendResponseObject } from '../types.js';
+/**
+ * Result of an APPEND: the destination, the selected mailbox path at the time of the append,
+ * and the UID information the server reported
+ */
+export interface AppendResult extends AppendResponseObject {
+    /** Path of the currently selected mailbox, if any */
+    path?: string | undefined;
+}
+/**
+ * Appends a message to a mailbox.
+ *
+ * @param connection - IMAP connection instance
+ * @param destination - Destination mailbox path
+ * @param content - Message content (RFC 822 format)
+ * @param flags - Message flags to set on the appended message
+ * @param idate - Internal date to set for the message
+ * @returns Append result with UID info if available, or undefined if preconditions not met
+ * @throws {Error} If the APPEND command fails or message exceeds APPENDLIMIT
+ */
+export default function append(connection: ImapFlow, destination: string | string[], content: Buffer | string, flags?: string | string[] | undefined, idate?: Date | string | false | undefined): Promise<AppendResult | undefined>;

package/{lib → dist/esm}/commands/append.js

@@ -1,39 +1,23 @@
-'use strict';
-
-const {
-    formatFlag,
-    canUseFlag,
-    formatDateTime,
-    normalizePath,
-    encodePath,
-    comparePaths,
-    enhanceCommandError,
-    parseBigIntValue,
-    parseUintValue,
-    MAX_UINT32_DIGITS
-} = require('../tools.js');
-
+import { formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comparePaths, enhanceCommandError, parseBigIntValue, parseUintValue, MAX_UINT32_DIGITS } from '../tools.js';
 /**
  * Appends a message to a mailbox.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} destination - Destination mailbox path
- * @param {Buffer|string} content - Message content (RFC 822 format)
- * @param {string|string[]} [flags] - Message flags to set on the appended message
- * @param {Date|string} [idate] - Internal date to set for the message
- * @returns {Promise<{destination: string, path?: string, uid?: number, uidValidity?: BigInt, seq?: number}|undefined>} Append result with UID info if available, or undefined if preconditions not met
+ * @param connection - IMAP connection instance
+ * @param destination - Destination mailbox path
+ * @param content - Message content (RFC 822 format)
+ * @param flags - Message flags to set on the appended message
+ * @param idate - Internal date to set for the message
+ * @returns Append result with UID info if available, or undefined if preconditions not met
  * @throws {Error} If the APPEND command fails or message exceeds APPENDLIMIT
  */
-module.exports = async (connection, destination, content, flags, idate) => {
+export default async function append(connection, destination, content, flags, idate) {
     if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !destination) {
         // nothing to do here
         return;
     }
-
     if (typeof content === 'string') {
         content = Buffer.from(content);
     }
-
     // APPENDLIMIT capability (RFC 7889): server may advertise the maximum message
     // size it accepts. Check before sending to avoid a wasted round-trip.
     if (connection.capabilities.has('APPENDLIMIT')) {
@@ -44,34 +28,26 @@ module.exports = async (connection, destination, content, flags, idate) => {
             throw err;
         }
     }
-
     destination = normalizePath(connection, destination);
-
     // If appending to the currently selected mailbox, we can listen for the
     // untagged EXISTS response to capture the new message's sequence number.
     let expectExists = comparePaths(connection, connection.mailbox.path, destination);
-
     // Validate and format flags. Only flags allowed by the mailbox's permanentFlags are included.
     flags = (Array.isArray(flags) ? flags : [].concat(flags || []))
         .map(flag => flag && formatFlag(flag.toString()))
-        .filter(flag => flag && canUseFlag(connection.mailbox, flag));
-
+        .filter((flag) => !!flag && canUseFlag(connection.mailbox, flag));
     // APPEND command format: APPEND <mailbox> [<flags>] [<date-time>] <literal>
     let attributes = [{ type: 'ATOM', value: encodePath(connection, destination) }];
-
     // Internal date: the date the server should record for this message.
     // Must be quoted (STRING type) per the IMAP date-time grammar.
     idate = idate ? formatDateTime(idate) : false;
-
     // Flags and date are optional; flags must come before date if both are present
     if (flags.length || idate) {
         attributes.push(flags.map(flag => ({ type: 'ATOM', value: flag })));
     }
-
     if (idate) {
         attributes.push({ type: 'STRING', value: idate });
     }
-
     // BINARY extension (RFC 3516): if the message content contains NUL bytes,
     // use literal8 syntax (~{size}\r\n) instead of regular literal ({size}\r\n).
     // Regular literals cannot contain NUL bytes per the IMAP grammar.
@@ -79,17 +55,14 @@ module.exports = async (connection, destination, content, flags, idate) => {
     if (connection.capabilities.has('BINARY') && !connection.disableBinary) {
         isLiteral8 = content.indexOf(Buffer.from([0])) >= 0;
     }
-
     attributes.push({ type: 'LITERAL', value: content, isLiteral8 });
-
     let map = { destination };
     if (connection.mailbox && connection.mailbox.path) {
         map.path = connection.mailbox.path;
     }
-
     // Handler for untagged EXISTS: captures the new message count which gives
     // us the sequence number of the appended message (it's the latest message).
-    const handleExistsUpdate = untagged => {
+    const handleExistsUpdate = (untagged) => {
         // The count is written into the live mailbox state below, so it has to clear the
         // same bar untaggedExists() applies: a digit run long enough to coerce to Infinity
         // would make resolveRange('*') compile to the literal string "Infinity" and break
@@ -99,34 +72,33 @@ module.exports = async (connection, destination, content, flags, idate) => {
             return;
         }
         map.seq = seq;
-
         // Update the connection's mailbox state and emit 'exists' event if the
         // count changed (notifies listeners about the new message).
         if (expectExists) {
-            let prevCount = connection.mailbox.exists;
+            let mailbox = connection.mailbox;
+            let prevCount = mailbox.exists;
             if (map.seq !== prevCount) {
-                connection.mailbox.exists = map.seq;
+                mailbox.exists = map.seq;
                 connection.emit('exists', {
-                    path: connection.mailbox.path,
+                    path: mailbox.path,
                     count: map.seq,
                     prevCount
                 });
             }
         }
     };
-
     let response;
     try {
         response = await connection.exec('APPEND', attributes, {
             // Only listen for EXISTS if we're appending to the currently selected mailbox
             untagged: expectExists ? { EXISTS: handleExistsUpdate } : false
         });
-
         // UIDPLUS (RFC 4315): the server may include APPENDUID response code in
         // the tagged OK. Format: [APPENDUID <uidValidity> <uid>]
         let section = response.response.attributes && response.response.attributes[0] && response.response.attributes[0].section;
         if (section && section.length) {
-            let responseCode = section[0] && typeof section[0].value === 'string' ? section[0].value : '';
+            let first = section[0];
+            let responseCode = first && typeof first.value === 'string' ? first.value : '';
             if (responseCode.toUpperCase() === 'APPENDUID') {
                 // Bounded digit runs only: isNaN() also passes '1e5', which BigInt() rejects
                 // with a throw - and this catch rethrows, so the append would reject after the
@@ -141,9 +113,7 @@ module.exports = async (connection, destination, content, flags, idate) => {
                 }
             }
         }
-
         response.next();
-
         // If we didn't get an EXISTS during APPEND (some servers don't send it
         // until the next command), issue a NOOP to flush pending notifications.
         if (expectExists && !map.seq) {
@@ -153,24 +123,24 @@ module.exports = async (connection, destination, content, flags, idate) => {
                     comment: 'Sequence not found from APPEND output'
                 });
                 response.next();
-            } catch (err) {
+            }
+            catch (err) {
                 connection.log.warn({ err, cid: connection.id });
             }
         }
-
         // If we have a sequence number but no UID (server doesn't support UIDPLUS),
         // look up the UID via SEARCH to provide a consistent result to the caller.
         if (map.seq && !map.uid) {
             let list = await connection.search({ seq: map.seq }, { uid: true });
-            if (list && list.length) {
+            if (Array.isArray(list) && list.length) {
                 map.uid = list[0];
             }
         }
-
         return map;
-    } catch (err) {
+    }
+    catch (err) {
         await enhanceCommandError(err);
         connection.log.warn({ err, cid: connection.id });
         throw err;
     }
-};
+}

package/dist/esm/commands/authenticate.d.ts

@@ -0,0 +1,24 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Credentials for the AUTHENTICATE command
+ */
+export interface AuthenticateCredentials {
+    /** OAuth2 access token for OAUTHBEARER/XOAUTH2 authentication */
+    accessToken?: string | undefined;
+    /** Password for PLAIN or LOGIN authentication */
+    password?: string | undefined;
+    /** Force a specific login method (e.g., 'AUTH=PLAIN', 'AUTH=LOGIN') */
+    loginMethod?: string | undefined;
+    /** Authorization identity for PLAIN authentication */
+    authzid?: string | undefined;
+}
+/**
+ * Authenticates user using the best available method.
+ *
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param credentials - Authentication credentials
+ * @returns The authenticated username, or undefined if already authenticated
+ * @throws {Error} If no supported authentication mechanism is available or if authentication fails
+ */
+export default function authenticate(connection: ImapFlow, username: string, { accessToken, password, loginMethod, authzid }: AuthenticateCredentials): Promise<string | undefined>;

package/{lib → dist/esm}/commands/authenticate.js

@@ -1,13 +1,10 @@
-'use strict';
-
-const { getStatusCode, getErrorText } = require('../tools.js');
-
+import { getStatusCode, getErrorText } from '../tools.js';
 /**
  * Handles authentication errors by enriching the error object with server response details.
  *
- * @param {Error} err - The original authentication error
- * @param {Object} [errorResponse] - Optional OAuth error response from the server
- * @returns {Error} The enriched error; the caller is expected to throw it
+ * @param err - The original authentication error
+ * @param errorResponse - Optional OAuth error response from the server
+ * @returns The enriched error; the caller is expected to throw it
  */
 async function handleAuthError(err, errorResponse) {
     let errorCode = getStatusCode(err.response);
@@ -21,21 +18,19 @@ async function handleAuthError(err, errorResponse) {
     }
     return err;
 }
-
 /**
  * Authenticates using OAuth (OAUTHBEARER or XOAUTH2).
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} username - The username to authenticate with
- * @param {string} accessToken - The OAuth2 access token
- * @returns {Promise<string>} The authenticated username
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param accessToken - The OAuth2 access token
+ * @returns The authenticated username
  * @throws {Error} If authentication fails
  */
 async function authOauth(connection, username, accessToken) {
     let oauthbearer;
     let command;
     let breaker;
-
     if (connection.capabilities.has('AUTH=OAUTHBEARER')) {
         // OAUTHBEARER payload per RFC 7628: fields separated by \x01 (SASL GS2 framing).
         // Format: "n,a=<user>," \x01 "host=..." \x01 "port=..." \x01 "auth=Bearer <token>" \x01 \x01
@@ -54,9 +49,10 @@ async function authOauth(connection, username, accessToken) {
             ''
         ].join('\x01');
         command = 'OAUTHBEARER';
-        // "AQ==" is base64 for \x01 -- sent as the error continuation to abort the SASL exchange
+        // "AQ==" is base64 for \x01, sent as the error continuation to abort the SASL exchange
         breaker = 'AQ==';
-    } else if (connection.capabilities.has('AUTH=XOAUTH') || connection.capabilities.has('AUTH=XOAUTH2')) {
+    }
+    else if (connection.capabilities.has('AUTH=XOAUTH') || connection.capabilities.has('AUTH=XOAUTH2')) {
         // XOAUTH2 payload (Google-specific): simpler format, also \x01-delimited.
         // Format: "user=<user>" \x01 "auth=Bearer <token>" \x01 \x01
         oauthbearer = [`user=${username}`, `auth=Bearer ${accessToken}`, '', ''].join('\x01');
@@ -64,54 +60,47 @@ async function authOauth(connection, username, accessToken) {
         // Empty breaker: XOAUTH2 expects an empty response to abort the SASL exchange
         breaker = '';
     }
-
     let errorResponse = false;
     try {
-        let response = await connection.exec(
-            'AUTHENTICATE',
-            [
-                { type: 'ATOM', value: command },
-                { type: 'ATOM', value: Buffer.from(oauthbearer).toString('base64'), sensitive: true }
-            ],
-            {
-                // Server sends a "+" continuation if auth fails, with a base64 JSON error payload.
-                // We decode it for diagnostics, then send the breaker to terminate the exchange.
-                onPlusTag: async resp => {
-                    if (resp.attributes && resp.attributes[0] && resp.attributes[0].type === 'TEXT') {
-                        try {
-                            errorResponse = JSON.parse(Buffer.from(resp.attributes[0].value, 'base64').toString());
-                        } catch (err) {
-                            connection.log.debug({
-                                msg: 'Failed to parse OAuth error response',
-                                errorResponse: resp.attributes[0].value,
-                                err,
-                                cid: connection.id
-                            });
-                        }
+        let response = await connection.exec('AUTHENTICATE', [
+            { type: 'ATOM', value: command },
+            { type: 'ATOM', value: Buffer.from(oauthbearer).toString('base64'), sensitive: true }
+        ], {
+            // Server sends a "+" continuation if auth fails, with a base64 JSON error payload.
+            // We decode it for diagnostics, then send the breaker to terminate the exchange.
+            onPlusTag: async (resp) => {
+                if (resp.attributes && resp.attributes[0] && resp.attributes[0].type === 'TEXT') {
+                    try {
+                        errorResponse = JSON.parse(Buffer.from(resp.attributes[0].value, 'base64').toString());
+                    }
+                    catch (err) {
+                        connection.log.debug({
+                            msg: 'Failed to parse OAuth error response',
+                            errorResponse: resp.attributes[0].value,
+                            err,
+                            cid: connection.id
+                        });
                     }
-
-                    connection.log.debug({ src: 'c', msg: breaker, comment: `Error response for ${command}`, cid: connection.id });
-                    connection.write(breaker);
                 }
+                connection.log.debug({ src: 'c', msg: breaker, comment: `Error response for ${command}`, cid: connection.id });
+                connection.write(breaker);
             }
-        );
+        });
         response.next();
-
         connection.authCapabilities.set(`AUTH=${command}`, true);
-
         return username;
-    } catch (err) {
+    }
+    catch (err) {
         throw await handleAuthError(err, errorResponse);
     }
 }
-
 /**
  * Authenticates using the SASL LOGIN mechanism.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} username - The username to authenticate with
- * @param {string} password - The password to authenticate with
- * @returns {Promise<string>} The authenticated username
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param password - The password to authenticate with
+ * @returns The authenticated username
  * @throws {Error} If authentication fails
  */
 async function authLogin(connection, username, password) {
@@ -120,47 +109,45 @@ async function authLogin(connection, username, password) {
         // SASL LOGIN is a challenge-response mechanism: the server sends base64-encoded
         // prompts ("Username:" and "Password:") and the client responds with base64-encoded values.
         let response = await connection.exec('AUTHENTICATE', [{ type: 'ATOM', value: 'LOGIN' }], {
-            onPlusTag: async resp => {
+            onPlusTag: async (resp) => {
                 if (resp.attributes && resp.attributes[0] && resp.attributes[0].type === 'TEXT') {
                     // Decode the server's base64 challenge to determine what it's asking for.
                     // Strip trailing colons and null bytes (\x00) that some servers append to the prompt.
                     let question = Buffer.from(resp.attributes[0].value, 'base64')
                         .toString()
                         .toLowerCase()
-                        .replace(/[:\x00]*$/, ''); // eslint-disable-line no-control-regex
-
+                        .replace(/[:\x00]*$/, '');
                     if (question === 'username' || question === 'user name') {
                         let encodedUsername = Buffer.from(username).toString('base64');
                         connection.log.debug({ src: 'c', msg: encodedUsername, comment: `Encoded username for AUTH=LOGIN`, cid: connection.id });
                         connection.write(encodedUsername);
-                    } else if (question === 'password') {
+                    }
+                    else if (question === 'password') {
                         connection.log.debug({ src: 'c', msg: '(* value hidden *)', comment: `Encoded password for AUTH=LOGIN`, cid: connection.id });
                         connection.write(Buffer.from(password).toString('base64'));
-                    } else {
+                    }
+                    else {
                         throw new Error(`Unknown LOGIN question "${question}"`);
                     }
                 }
             }
         });
-
         response.next();
-
         connection.authCapabilities.set(`AUTH=LOGIN`, true);
-
         return username;
-    } catch (err) {
+    }
+    catch (err) {
         throw await handleAuthError(err, errorResponse);
     }
 }
-
 /**
  * Authenticates using the SASL PLAIN mechanism.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} username - The authentication identity (authcid)
- * @param {string} password - The password to authenticate with
- * @param {string} [authzid] - Optional authorization identity to impersonate
- * @returns {Promise<string>} The authorized identity (authzid if provided, otherwise username)
+ * @param connection - IMAP connection instance
+ * @param username - The authentication identity (authcid)
+ * @param password - The password to authenticate with
+ * @param authzid - Optional authorization identity to impersonate
+ * @returns The authorized identity (authzid if provided, otherwise username)
  * @throws {Error} If authentication fails
  */
 async function authPlain(connection, username, password, authzid) {
@@ -183,61 +170,49 @@ async function authPlain(connection, username, password, authzid) {
                 connection.write(encodedResponse);
             }
         });
-
         response.next();
-
         connection.authCapabilities.set(`AUTH=PLAIN`, true);
-
         // Return the identity we're authorized as (authzid if provided, otherwise username)
         return authzid || username;
-    } catch (err) {
+    }
+    catch (err) {
         throw await handleAuthError(err, errorResponse);
     }
 }
-
 /**
  * Authenticates user using the best available method.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} username - The username to authenticate with
- * @param {Object} credentials - Authentication credentials
- * @param {string} [credentials.accessToken] - OAuth2 access token for OAUTHBEARER/XOAUTH2 authentication
- * @param {string} [credentials.password] - Password for PLAIN or LOGIN authentication
- * @param {string} [credentials.loginMethod] - Force a specific login method (e.g., 'AUTH=PLAIN', 'AUTH=LOGIN')
- * @param {string} [credentials.authzid] - Authorization identity for PLAIN authentication
- * @returns {Promise<string|undefined>} The authenticated username, or undefined if already authenticated
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param credentials - Authentication credentials
+ * @returns The authenticated username, or undefined if already authenticated
  * @throws {Error} If no supported authentication mechanism is available or if authentication fails
  */
-module.exports = async (connection, username, { accessToken, password, loginMethod, authzid }) => {
+export default async function authenticate(connection, username, { accessToken, password, loginMethod, authzid }) {
     if (connection.state !== connection.states.NOT_AUTHENTICATED) {
         // nothing to do here
         return;
     }
-
     // Authentication method selection order:
-    // 1. OAuth (OAUTHBEARER > XOAUTH2) -- preferred when an accessToken is provided,
+    // 1. OAuth (OAUTHBEARER > XOAUTH2), preferred when an accessToken is provided,
     //    as it avoids transmitting passwords entirely.
-    // 2. SASL PLAIN -- preferred over LOGIN because it supports authzid (impersonation)
+    // 2. SASL PLAIN, preferred over LOGIN because it supports authzid (impersonation)
     //    and sends credentials in a single round trip.
-    // 3. SASL LOGIN -- fallback; an older challenge-response mechanism (two round trips).
+    // 3. SASL LOGIN, the fallback; an older challenge-response mechanism (two round trips).
     // If loginMethod is explicitly set, it overrides the automatic capability-based selection.
-
     if (accessToken) {
         // AUTH=OAUTHBEARER and AUTH=XOAUTH in the context of OAuth2 or very similar so we can handle these together
         if (connection.capabilities.has('AUTH=OAUTHBEARER') || connection.capabilities.has('AUTH=XOAUTH') || connection.capabilities.has('AUTH=XOAUTH2')) {
             return await authOauth(connection, username, accessToken);
         }
     }
-
     if (password) {
         if ((!loginMethod && connection.capabilities.has('AUTH=PLAIN')) || loginMethod === 'AUTH=PLAIN') {
             return await authPlain(connection, username, password, authzid);
         }
-
         if ((!loginMethod && connection.capabilities.has('AUTH=LOGIN')) || loginMethod === 'AUTH=LOGIN') {
             return await authLogin(connection, username, password);
         }
     }
-
     throw new Error('Unsupported authentication mechanism');
-};
+}

package/dist/esm/commands/capability.d.ts

@@ -0,0 +1,8 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Refreshes capabilities from server.
+ *
+ * @param connection - IMAP connection instance
+ * @returns Server capabilities map, or false on failure
+ */
+export default function capability(connection: ImapFlow): Promise<Map<string, boolean | number> | false>;

package/{lib → dist/esm}/commands/capability.js

@@ -1,30 +1,27 @@
-'use strict';
-
 /**
  * Refreshes capabilities from server.
  *
- * @param {Object} connection - IMAP connection instance
- * @returns {Promise<Map|boolean>} Server capabilities map, or false on failure
+ * @param connection - IMAP connection instance
+ * @returns Server capabilities map, or false on failure
  */
 // Capabilities are normally received and updated by the global response handler
 // (e.g., from the server greeting or after authentication). This explicit CAPABILITY
 // command is only needed when capabilities must be refreshed on demand, such as
 // after STARTTLS or when the server signals a capability change.
-module.exports = async connection => {
+export default async function capability(connection) {
     if (connection.capabilities.size && !connection.expectCapabilityUpdate) {
         return connection.capabilities;
     }
-
     let response;
     try {
         // The actual parsing of the untagged CAPABILITY response is handled by the
         // global handler, not here. We just trigger the server to send it.
         response = await connection.exec('CAPABILITY');
-
         response.next();
         return connection.capabilities;
-    } catch (err) {
+    }
+    catch (err) {
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-};
+}

package/dist/esm/commands/close.d.ts

@@ -0,0 +1,8 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Closes the currently selected mailbox.
+ *
+ * @param connection - IMAP connection instance
+ * @returns True on success, false on failure, or undefined if not in SELECTED state
+ */
+export default function close(connection: ImapFlow): Promise<boolean | undefined>;

package/{lib → dist/esm}/commands/close.js

@@ -1,17 +1,14 @@
-'use strict';
-
 /**
  * Closes the currently selected mailbox.
  *
- * @param {Object} connection - IMAP connection instance
- * @returns {Promise<boolean|undefined>} True on success, false on failure, or undefined if not in SELECTED state
+ * @param connection - IMAP connection instance
+ * @returns True on success, false on failure, or undefined if not in SELECTED state
  */
-module.exports = async connection => {
+export default async function close(connection) {
     if (connection.state !== connection.states.SELECTED) {
         // nothing to do here
         return;
     }
-
     let response;
     try {
         // IMAP CLOSE (RFC 3501 6.4.2): permanently removes all messages flagged \Deleted
@@ -19,20 +16,19 @@ module.exports = async connection => {
         // Unlike EXPUNGE, CLOSE does not send individual untagged EXPUNGE responses.
         response = await connection.exec('CLOSE');
         response.next();
-
         // Transition from SELECTED back to AUTHENTICATED state.
         // Clear mailbox metadata so subsequent operations know no mailbox is selected.
         let currentMailbox = connection.mailbox;
         connection.mailbox = false;
         connection.currentSelectCommand = false;
         connection.state = connection.states.AUTHENTICATED;
-
         if (currentMailbox) {
             connection.emit('mailboxClose', currentMailbox);
         }
         return true;
-    } catch (err) {
+    }
+    catch (err) {
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-};
+}

package/dist/esm/commands/compress.d.ts

@@ -0,0 +1,8 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Requests DEFLATE compression from the server.
+ *
+ * @param connection - IMAP connection instance
+ * @returns True if compression was enabled, false otherwise
+ */
+export default function compress(connection: ImapFlow): Promise<boolean>;