imapflow 1.7.8 → 2.0.1

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

@@ -1,30 +1,27 @@
-'use strict';
-
 /**
  * Requests DEFLATE compression from the server.
  *
- * @param {Object} connection - IMAP connection instance
- * @returns {Promise<boolean>} True if compression was enabled, false otherwise
+ * @param connection - IMAP connection instance
+ * @returns True if compression was enabled, false otherwise
  */
 // COMPRESS=DEFLATE (RFC 4978): enables zlib compression on the IMAP connection
 // to reduce bandwidth. Once enabled, all subsequent data in both directions is compressed.
-module.exports = async connection => {
+export default async function compress(connection) {
     // Skip if the server doesn't support COMPRESS=DEFLATE, or if compression
     // is already active (connection._inflate exists) to avoid double-compression.
     if (!connection.capabilities.has('COMPRESS=DEFLATE') || connection._inflate) {
         // nothing to do here
         return false;
     }
-
     let response;
     try {
         response = await connection.exec('COMPRESS', [{ type: 'ATOM', value: 'DEFLATE' }]);
-    } catch (err) {
+    }
+    catch (err) {
         // The server declined (NO/BAD): nothing switched, staying uncompressed is safe.
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-
     // Everything after the tagged OK is already deflate-framed (RFC 4978 section 4) -
     // the server switches at the OK, so declining the upgrade at this point is not a
     // protocol option. The socket stays piped into the plaintext parser until the
@@ -42,14 +39,13 @@ module.exports = async connection => {
         // Schedule the close before releasing parser backpressure, so the buffered
         // deflate-framed bytes cannot settle anything before teardown begins. This is
         // why the decision lives here rather than at the connection layer the way the
-        // STARTTLS guard does (starttls.js records a flag, upgradeToSTARTTLS decides):
+        // STARTTLS guard does (starttls.ts records a flag, upgradeToSTARTTLS decides):
         // only the command module holds the response before its backpressure release,
         // so only it can order teardown ahead of that release.
         connection.closeAfter();
         response.next();
         throw error;
     }
-
     response.next();
     return true;
-};
+}

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

@@ -0,0 +1,13 @@
+import type { ImapFlow } from '../imap-flow.js';
+import type { CopyResponseObject, MessageRangeOptions } from '../types.js';
+/**
+ * Copies messages from the current mailbox to another mailbox.
+ *
+ * @param connection - IMAP connection instance
+ * @param range - Message sequence number or UID range
+ * @param destination - Destination mailbox path
+ * @param options - Copy options
+ * @param options.uid - If true, use UID COPY instead of COPY
+ * @returns Copy result with UID mapping if available, false on failure, or undefined if preconditions not met
+ */
+export default function copy(connection: ImapFlow, range: string, destination: string | string[], options?: MessageRangeOptions | undefined): Promise<CopyResponseObject | false | undefined>;

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

@@ -1,47 +1,39 @@
-'use strict';
-
-const { normalizePath, encodePath, enhanceCommandError } = require('../tools.js');
-const { parseCopyUid } = require('./copyuid-parser.js');
-
+import { normalizePath, encodePath, enhanceCommandError } from '../tools.js';
+import { parseCopyUid } from './copyuid-parser.js';
 /**
  * Copies messages from the current mailbox to another mailbox.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} range - Message sequence number or UID range
- * @param {string} destination - Destination mailbox path
- * @param {Object} [options] - Copy options
- * @param {boolean} [options.uid] - If true, use UID COPY instead of COPY
- * @returns {Promise<{path: string, destination: string, uidValidity?: BigInt, uidMap?: Map}|boolean|undefined>} Copy result with UID mapping if available, false on failure, or undefined if preconditions not met
+ * @param connection - IMAP connection instance
+ * @param range - Message sequence number or UID range
+ * @param destination - Destination mailbox path
+ * @param options - Copy options
+ * @param options.uid - If true, use UID COPY instead of COPY
+ * @returns Copy result with UID mapping if available, false on failure, or undefined if preconditions not met
  */
-module.exports = async (connection, range, destination, options) => {
+export default async function copy(connection, range, destination, options) {
     if (connection.state !== connection.states.SELECTED || !range || !destination) {
         // nothing to do here
         return;
     }
-
     options = options || {};
     destination = normalizePath(connection, destination);
-
     let attributes = [
         { type: 'SEQUENCE', value: range },
         { type: 'ATOM', value: encodePath(connection, destination) }
     ];
-
     let response;
     try {
         response = await connection.exec(options.uid ? 'UID COPY' : 'COPY', attributes);
         response.next();
-
         let map = { path: connection.mailbox.path, destination };
-
         // UIDPLUS (RFC 4315): the server may include a COPYUID response code in the
         // tagged OK response, providing a mapping from source UIDs to destination UIDs.
         parseCopyUid(response.response, map);
-
         return map;
-    } catch (err) {
+    }
+    catch (err) {
         await enhanceCommandError(err);
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-};
+}

package/dist/esm/commands/copyuid-parser.d.ts

@@ -0,0 +1,11 @@
+import type { ImapResponse } from '../handler/types.js';
+import type { CopyResponseObject } from '../types.js';
+/**
+ * Parses COPYUID response code from an IMAP response (RFC 4315).
+ * Used by both COPY and MOVE commands to extract the UID mapping
+ * from source mailbox to destination mailbox.
+ *
+ * @param response - IMAP response object with attributes
+ * @param map - Result map to populate with uidValidity and uidMap
+ */
+export declare function parseCopyUid(response: ImapResponse, map: CopyResponseObject): void;

package/{lib → dist/esm}/commands/copyuid-parser.js

@@ -1,35 +1,29 @@
-'use strict';
-
-const { expandRange, parseBigIntValue } = require('../tools.js');
-
+import { expandRange, parseBigIntValue } from '../tools.js';
 /**
  * Parses COPYUID response code from an IMAP response (RFC 4315).
  * Used by both COPY and MOVE commands to extract the UID mapping
  * from source mailbox to destination mailbox.
  *
- * @param {Object} response - IMAP response object with attributes
- * @param {Object} map - Result map to populate with uidValidity and uidMap
+ * @param response - IMAP response object with attributes
+ * @param map - Result map to populate with uidValidity and uidMap
  */
-function parseCopyUid(response, map) {
+export function parseCopyUid(response, map) {
     let section = response.attributes && response.attributes[0] && response.attributes[0].section;
     let responseCode = section && section.length && section[0] && typeof section[0].value === 'string' ? section[0].value : '';
-
     if (responseCode !== 'COPYUID') {
         return;
     }
-
+    // A COPYUID code always comes with its section, see responseCode above
+    let codeSection = section;
     // Only a bounded pure digit string is accepted: isNaN() also passes values like "1e5" or
     // "Infinity", which BigInt() then rejects with a throw that loses the uidMap.
-    let uidValidity = parseBigIntValue(section[1] && section[1].value);
+    let uidValidity = parseBigIntValue(codeSection[1] && codeSection[1].value);
     if (uidValidity !== false) {
         map.uidValidity = uidValidity;
     }
-
-    let sourceUids = section[2] && typeof section[2].value === 'string' ? expandRange(section[2].value) : false;
-    let destinationUids = section[3] && typeof section[3].value === 'string' ? expandRange(section[3].value) : false;
+    const sourceUids = codeSection[2] && typeof codeSection[2].value === 'string' ? expandRange(codeSection[2].value) : false;
+    const destinationUids = codeSection[3] && typeof codeSection[3].value === 'string' ? expandRange(codeSection[3].value) : false;
     if (sourceUids && destinationUids && sourceUids.length === destinationUids.length) {
         map.uidMap = new Map(sourceUids.map((uid, i) => [uid, destinationUids[i]]));
     }
 }
-
-module.exports = { parseCopyUid };

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

@@ -0,0 +1,11 @@
+import type { ImapFlow } from '../imap-flow.js';
+import type { MailboxCreateResponse } from '../types.js';
+/**
+ * Creates a new mailbox and subscribes to it.
+ *
+ * @param connection - IMAP connection instance
+ * @param path - Mailbox path to create
+ * @returns Object with path and creation status, or undefined if preconditions not met
+ * @throws If the CREATE command fails (except when mailbox already exists)
+ */
+export default function create(connection: ImapFlow, path: string | string[]): Promise<MailboxCreateResponse | undefined>;

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

@@ -1,40 +1,32 @@
-'use strict';
-
-const { encodePath, normalizePath, getStatusCode, enhanceCommandError } = require('../tools.js');
-
+import { encodePath, normalizePath, getStatusCode, enhanceCommandError } from '../tools.js';
 /**
  * Creates a new mailbox and subscribes to it.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} path - Mailbox path to create
- * @returns {Promise<{path: string, created: boolean, mailboxId?: string}|undefined>} Object with path and creation status, or undefined if preconditions not met
- * @throws {Error} If the CREATE command fails (except when mailbox already exists)
+ * @param connection - IMAP connection instance
+ * @param path - Mailbox path to create
+ * @returns Object with path and creation status, or undefined if preconditions not met
+ * @throws If the CREATE command fails (except when mailbox already exists)
  */
-module.exports = async (connection, path) => {
+export default async function create(connection, path) {
     if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         // nothing to do here
         return;
     }
-
     path = normalizePath(connection, path);
-
     let response;
     try {
         let map = {
             path
         };
         response = await connection.exec('CREATE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
-
         // Parse the response code section (e.g., [MAILBOXID (<id>)]) from the tagged OK response.
         // IMAP response code attributes are structured as alternating key-value pairs.
-        let section =
-            response.response.attributes &&
+        let section = response.response.attributes &&
             response.response.attributes[0] &&
             response.response.attributes[0].section &&
             response.response.attributes[0].section.length
-                ? response.response.attributes[0].section
-                : false;
-
+            ? response.response.attributes[0].section
+            : false;
         if (section) {
             let key;
             section.forEach((attribute, i) => {
@@ -43,11 +35,9 @@ module.exports = async (connection, path) => {
                     key = attribute && typeof attribute.value === 'string' ? attribute.value : false;
                     return;
                 }
-
                 if (!key) {
                     return;
                 }
-
                 let value;
                 switch (key.toLowerCase()) {
                     case 'mailboxid':
@@ -55,25 +45,22 @@ module.exports = async (connection, path) => {
                         value = Array.isArray(attribute) && attribute[0] && typeof attribute[0].value === 'string' ? attribute[0].value : false;
                         break;
                 }
-
                 if (key && value) {
                     map[key] = value;
                 }
             });
         }
-
         map.created = true;
         response.next();
-
         // Auto-subscribe after creation so the new mailbox appears in LSUB listings
         // and is visible to clients that only show subscribed folders.
         await connection.run('SUBSCRIBE', path);
-
         return map;
-    } catch (err) {
+    }
+    catch (err) {
         let errorCode = getStatusCode(err.response);
         // ALREADYEXISTS (RFC 5530) means the mailbox already exists on the server.
-        // This is not a true error -- we return created:false to indicate nothing was created.
+        // This is not a true error, we return created:false to indicate nothing was created.
         if (errorCode === 'ALREADYEXISTS') {
             // no need to do anything, mailbox already exists
             return {
@@ -81,9 +68,8 @@ module.exports = async (connection, path) => {
                 created: false
             };
         }
-
         await enhanceCommandError(err);
         connection.log.warn({ err, cid: connection.id });
         throw err;
     }
-};
+}

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

@@ -0,0 +1,11 @@
+import type { ImapFlow } from '../imap-flow.js';
+import type { MailboxDeleteResponse } from '../types.js';
+/**
+ * Deletes an existing mailbox.
+ *
+ * @param connection - IMAP connection instance
+ * @param path - Mailbox path to delete
+ * @returns Object with the deleted path, or undefined if preconditions not met
+ * @throws If the DELETE command fails
+ */
+export default function deleteMailbox(connection: ImapFlow, path: string | string[]): Promise<MailboxDeleteResponse | undefined>;

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

@@ -1,29 +1,23 @@
-'use strict';
-
-const { encodePath, normalizePath, enhanceCommandError } = require('../tools.js');
-
+import { encodePath, normalizePath, enhanceCommandError } from '../tools.js';
 /**
  * Deletes an existing mailbox.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} path - Mailbox path to delete
- * @returns {Promise<{path: string}|undefined>} Object with the deleted path, or undefined if preconditions not met
- * @throws {Error} If the DELETE command fails
+ * @param connection - IMAP connection instance
+ * @param path - Mailbox path to delete
+ * @returns Object with the deleted path, or undefined if preconditions not met
+ * @throws If the DELETE command fails
  */
-module.exports = async (connection, path) => {
+export default async function deleteMailbox(connection, path) {
     if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
         // nothing to do here
         return;
     }
-
     path = normalizePath(connection, path);
-
     // If the mailbox to delete is currently selected, we must close/deselect it first.
     // IMAP servers reject DELETE on the currently selected mailbox (RFC 3501 6.3.4).
     if (connection.state === connection.states.SELECTED && connection.mailbox.path === path) {
         await connection.run('CLOSE');
     }
-
     let response;
     try {
         let map = {
@@ -32,9 +26,10 @@ module.exports = async (connection, path) => {
         response = await connection.exec('DELETE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return map;
-    } catch (err) {
+    }
+    catch (err) {
         await enhanceCommandError(err);
         connection.log.warn({ err, cid: connection.id });
         throw err;
     }
-};
+}

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

@@ -0,0 +1,9 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Enables IMAP extensions on the server.
+ *
+ * @param connection - IMAP connection instance
+ * @param extensionList - List of extension names to enable
+ * @returns Set of enabled extensions, false on failure, or undefined if not applicable
+ */
+export default function enable(connection: ImapFlow, extensionList: string[]): Promise<Set<string> | false | undefined>;

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

@@ -1,21 +1,17 @@
-'use strict';
-
-const { hasCapability } = require('../tools.js');
-
+import { hasCapability } from '../tools.js';
 /**
  * Enables IMAP extensions on the server.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string[]} extensionList - List of extension names to enable
- * @returns {Promise<Set|boolean|undefined>} Set of enabled extensions, false on failure, or undefined if not applicable
+ * @param connection - IMAP connection instance
+ * @param extensionList - List of extension names to enable
+ * @returns Set of enabled extensions, false on failure, or undefined if not applicable
  */
-module.exports = async (connection, extensionList) => {
+export default async function enable(connection, extensionList) {
     // ENABLE is part of base IMAP4rev2, so rev2-only servers may omit the token
     if (!hasCapability(connection, 'ENABLE') || connection.state !== connection.states.AUTHENTICATED) {
         // nothing to do here
         return;
     }
-
     // Pre-filter: only request extensions the server actually advertised in its
     // CAPABILITY response. Requesting unsupported extensions would cause an error.
     // Compared case-insensitively - the capability map keeps canonical casing for
@@ -25,39 +21,36 @@ module.exports = async (connection, extensionList) => {
     if (!extensionList.length) {
         return;
     }
-
     let response;
     try {
         let enabled = new Set();
-        response = await connection.exec(
-            'ENABLE',
-            extensionList.map(extension => ({ type: 'ATOM', value: extension.toUpperCase() })),
-            {
-                untagged: {
-                    // The untagged ENABLED response is a flat list of extension names
-                    // (e.g., "* ENABLED CONDSTORE UTF8=ACCEPT"), NOT key-value pairs.
-                    // Each attribute is a single extension identifier.
-                    ENABLED: async untagged => {
-                        if (!untagged.attributes || !untagged.attributes.length) {
-                            return;
-                        }
-                        untagged.attributes.forEach(attr => {
-                            if (attr.value && typeof attr.value === 'string') {
-                                enabled.add(attr.value.toUpperCase().trim());
-                            }
-                        });
+        response = await connection.exec('ENABLE', extensionList.map((extension) => ({ type: 'ATOM', value: extension.toUpperCase() })), {
+            untagged: {
+                // The untagged ENABLED response is a flat list of extension names
+                // (e.g., "* ENABLED CONDSTORE UTF8=ACCEPT"), NOT key-value pairs.
+                // Each attribute is a single extension identifier.
+                ENABLED: async (untagged) => {
+                    if (!untagged.attributes || !untagged.attributes.length) {
+                        return;
                     }
+                    untagged.attributes.forEach(attr => {
+                        let value = attr.value;
+                        if (value && typeof value === 'string') {
+                            enabled.add(value.toUpperCase().trim());
+                        }
+                    });
                 }
             }
-        );
+        });
         // Merge instead of replace - the untagged ENABLED response only lists
         // extensions enabled by this command (RFC 5161), so a replace would drop
         // grants from an earlier ENABLE call
         connection.enabled = new Set([...connection.enabled, ...enabled]);
         response.next();
         return connection.enabled;
-    } catch (err) {
+    }
+    catch (err) {
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-};
+}

package/dist/esm/commands/esearch-parser.d.ts

@@ -0,0 +1,17 @@
+import type { ImapAttributeList } from '../handler/types.js';
+import type { ESearchResult } from '../types.js';
+/**
+ * Parses the key-value attributes from an ESEARCH untagged response.
+ *
+ * Receives the attribute list AFTER stripping the leading (TAG "X") list
+ * and the UID atom, i.e. only the result keyword/value pairs remain.
+ *
+ * ALL and PARTIAL.messages are kept as compact sequence-set strings.
+ * Use expandRange() from tools.ts if you need to expand them.
+ * MODSEQ (RFC 7162, sent when the search used a MODSEQ criterion) is
+ * returned as a BigInt.
+ *
+ * @param attrs - Attribute array from the IMAP parser
+ * @returns ESearchResult object
+ */
+export declare function parseEsearchResponse(attrs: ImapAttributeList): ESearchResult;

package/dist/esm/commands/esearch-parser.js

@@ -0,0 +1,88 @@
+import { parseBigIntValue, parseUintValue, MAX_UINT32_DIGITS } from '../tools.js';
+/**
+ * Parses the key-value attributes from an ESEARCH untagged response.
+ *
+ * Receives the attribute list AFTER stripping the leading (TAG "X") list
+ * and the UID atom, i.e. only the result keyword/value pairs remain.
+ *
+ * ALL and PARTIAL.messages are kept as compact sequence-set strings.
+ * Use expandRange() from tools.ts if you need to expand them.
+ * MODSEQ (RFC 7162, sent when the search used a MODSEQ criterion) is
+ * returned as a BigInt.
+ *
+ * @param attrs - Attribute array from the IMAP parser
+ * @returns ESearchResult object
+ */
+export function parseEsearchResponse(attrs) {
+    const result = {};
+    let i = 0;
+    while (i < attrs.length) {
+        const token = attrs[i];
+        if (!token || token.type !== 'ATOM') {
+            i++;
+            continue;
+        }
+        const key = token.value.toUpperCase();
+        if (i + 1 >= attrs.length) {
+            i++;
+            continue;
+        }
+        switch (key) {
+            // COUNT is a plain message count; MIN and MAX are sequence numbers or UIDs. All
+            // three are bounded decimal runs - isNaN() would also admit '1e400' (Infinity)
+            case 'COUNT': {
+                const n = parseUintValue(attrs[++i]?.value, MAX_UINT32_DIGITS);
+                if (n !== false)
+                    result.count = n;
+                break;
+            }
+            case 'MIN': {
+                const n = parseUintValue(attrs[++i]?.value, MAX_UINT32_DIGITS);
+                if (n !== false)
+                    result.min = n;
+                break;
+            }
+            case 'MAX': {
+                const n = parseUintValue(attrs[++i]?.value, MAX_UINT32_DIGITS);
+                if (n !== false)
+                    result.max = n;
+                break;
+            }
+            case 'MODSEQ': {
+                // RFC 7162 section 3.1.5: present when the SEARCH used a MODSEQ
+                // criterion on a CONDSTORE-enabled session. BigInt because
+                // mod-sequence values are unsigned 63-bit
+                const modseq = parseBigIntValue(attrs[++i]?.value);
+                if (modseq !== false)
+                    result.modseq = modseq;
+                break;
+            }
+            case 'ALL': {
+                const allToken = attrs[++i];
+                if (allToken && typeof allToken.value === 'string') {
+                    result.all = allToken.value;
+                }
+                break;
+            }
+            case 'PARTIAL': {
+                const listToken = attrs[++i];
+                const items = Array.isArray(listToken) ? listToken : null;
+                if (!items || items.length < 2)
+                    break;
+                result.partial = {
+                    range: items[0].value,
+                    messages: items[1].value
+                };
+                break;
+            }
+            default:
+                // Skip the value token for unknown keys to keep the stream aligned.
+                // The loop's unconditional i++ at the bottom advances past the key;
+                // this extra i++ advances past the value token.
+                i++;
+                break;
+        }
+        i++;
+    }
+    return result;
+}

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

@@ -0,0 +1,12 @@
+import type { ImapFlow } from '../imap-flow.js';
+import type { MessageRangeOptions } from '../types.js';
+/**
+ * Deletes specified messages by flagging them as Deleted and expunging.
+ *
+ * @param connection - IMAP connection instance
+ * @param range - Message sequence number or UID range
+ * @param options - Expunge options
+ * @param options.uid - If true, use UID EXPUNGE when UIDPLUS is available
+ * @returns True on success, false on failure, or undefined if preconditions not met
+ */
+export default function expunge(connection: ImapFlow, range: string, options?: MessageRangeOptions | undefined): Promise<boolean | undefined>;

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

@@ -1,60 +1,55 @@
-'use strict';
-
-const { enhanceCommandError, hasCapability, parseBigIntValue } = require('../tools.js');
-
+import { enhanceCommandError, hasCapability, parseBigIntValue } from '../tools.js';
 /**
  * Deletes specified messages by flagging them as Deleted and expunging.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} range - Message sequence number or UID range
- * @param {Object} [options] - Expunge options
- * @param {boolean} [options.uid] - If true, use UID EXPUNGE when UIDPLUS is available
- * @returns {Promise<boolean|undefined>} True on success, false on failure, or undefined if preconditions not met
+ * @param connection - IMAP connection instance
+ * @param range - Message sequence number or UID range
+ * @param options - Expunge options
+ * @param options.uid - If true, use UID EXPUNGE when UIDPLUS is available
+ * @returns True on success, false on failure, or undefined if preconditions not met
  */
-module.exports = async (connection, range, options) => {
+export default async function expunge(connection, range, options) {
     if (connection.state !== connection.states.SELECTED || !range) {
         // nothing to do here
         return;
     }
-
     options = options || {};
-
     // Two-step deletion process per IMAP protocol:
     // Step 1: Mark the target messages with the \Deleted flag.
     await connection.messageFlagsAdd(range, ['\\Deleted'], options);
-
     // Step 2: Issue EXPUNGE to permanently remove \Deleted messages.
     // With UIDPLUS (RFC 4315): "UID EXPUNGE <uids>" removes only the specified UIDs,
-    // leaving other \Deleted messages untouched -- important for concurrent access.
+    // leaving other \Deleted messages untouched, important for concurrent access.
     // Without UIDPLUS: plain "EXPUNGE" removes ALL messages flagged \Deleted in the mailbox.
     let byUid = options.uid && hasCapability(connection, 'UIDPLUS');
     let command = byUid ? 'UID EXPUNGE' : 'EXPUNGE';
     let attributes = byUid ? [{ type: 'SEQUENCE', value: range }] : false;
-
     let response;
     try {
         response = await connection.exec(command, attributes);
-
         // CONDSTORE (RFC 7162): the server may return HIGHESTMODSEQ in the response code
         // (e.g., "A OK [HIGHESTMODSEQ 9122] Expunge completed").
         // Track this so the client can detect concurrent mailbox changes via mod-sequences.
         let section = response.response.attributes && response.response.attributes[0] && response.response.attributes[0].section;
         let responseCode = section && section.length && section[0] && typeof section[0].value === 'string' ? section[0].value : '';
         if (responseCode.toUpperCase() === 'HIGHESTMODSEQ') {
+            // A response code always comes with its section, see responseCode above
+            let codeSection = section;
+            let mailbox = connection.mailbox;
             // Bounded digit runs only: isNaN() also passes '1e5', which BigInt() rejects with
             // a throw that the catch below would swallow, making messageDelete() report false
             // even though the server expunged the messages.
-            let highestModseq = parseBigIntValue(section[1] && section[1].value);
-            if (highestModseq && (!connection.mailbox.highestModseq || highestModseq > connection.mailbox.highestModseq)) {
-                connection.mailbox.highestModseq = highestModseq;
+            let highestModseq = parseBigIntValue(codeSection[1] && codeSection[1].value);
+            if (highestModseq && (!mailbox.highestModseq || highestModseq > mailbox.highestModseq)) {
+                mailbox.highestModseq = highestModseq;
             }
         }
-
         response.next();
         return true;
-    } catch (err) {
+    }
+    catch (err) {
         await enhanceCommandError(err);
         connection.log.warn({ err, cid: connection.id });
         return false;
     }
-};
+}