imapflow 2.0.8 → 2.1.1

package/dist/esm/imap-flow.js

@@ -7,7 +7,7 @@ import crypto from 'node:crypto';
 import zlib from 'node:zlib';
 import { EventEmitter } from 'node:events';
 import { PassThrough } from 'node:stream';
-import logger from './logger.js';
+import { createConnectionLogger } from './logger.js';
 import * as packageInfo from './package-info.js';
 import { ImapStream } from './handler/imap-stream.js';
 import { parser, compiler } from './handler/imap-handler.js';
@@ -17,7 +17,7 @@ import { downloadMessage, downloadMessageParts } from './download.js';
 import { AuthenticationFailure } from './errors.js';
 import imapCommands from './imap-commands.js';
 import { comparePaths, updateCapabilities, getFolderTree, formatMessageResponse, packMessageRange, normalizePath, expandRange, getColorFlags, hasCapability, isRev2Active, logConnectionError, unrefTimer, clearTimer, parseUintValue, getStringList, getTextValues, emitSafe, buildConnectionError, guardedPromise, guardedReject, MAX_UINT32_DIGITS } from './tools.js';
-export { AuthenticationFailure } from './errors.js';
+export { AuthenticationFailure, ImapFlowErrorCode } from './errors.js';
 const GREETING_TIMEOUT = 16 * 1000;
 const UPGRADE_TIMEOUT = 10 * 1000;
 const SOCKET_TIMEOUT = 5 * 60 * 1000;
@@ -1561,6 +1561,7 @@ export class ImapFlow extends EventEmitter {
     /** @internal */
     beginSession(onUnhandledError) {
         clearTimer(this.greetingTimeout);
+        this.greetingReceived = true;
         this.untaggedHandlers.OK = null;
         this.untaggedHandlers.PREAUTH = null;
         if (this.isClosed) {
@@ -1620,6 +1621,12 @@ export class ImapFlow extends EventEmitter {
         this.byeReason = reason || 'Server closed connection';
         this.untaggedHandlers.BYE = null;
         this.state = this.states.LOGOUT;
+        // A BYE greeting rejects the connection outright. Do not wait for the server to close
+        // the socket: one that keeps it open would leave connect() pending until the greeting
+        // timeout.
+        if (!this.greetingReceived) {
+            this.closeAfter();
+        }
     }
     // Drops every capability-derived field together - the counterpart of
     // updateCapabilitiesFromRaw() below, which sets them together. rawCapabilities is
@@ -1852,7 +1859,7 @@ export class ImapFlow extends EventEmitter {
     /** @internal */
     autoidle() {
         clearTimer(this.idleStartTimer);
-        if (this.options.disableAutoIdle || this.state !== this.states.SELECTED) {
+        if (this.options.disableAutoIdle || !this.usable || this.state !== this.states.SELECTED) {
             return;
         }
         if (this.connectionBusy()) {
@@ -1864,7 +1871,7 @@ export class ImapFlow extends EventEmitter {
             // missed clearTimeout would inject IDLE between a caller's own commands. Declining
             // postpones rather than cancels: whatever made the connection busy calls autoidle()
             // again when it finishes.
-            if (this.state !== this.states.SELECTED || this.connectionBusy()) {
+            if (!this.usable || this.state !== this.states.SELECTED || this.connectionBusy()) {
                 return;
             }
             this.idle().catch(err => logConnectionError(this, 'Auto-IDLE failed', err));
@@ -1883,9 +1890,17 @@ export class ImapFlow extends EventEmitter {
     async connect() {
         if (this._connectCalled) {
             // Prevent re-using ImapFlow instances by allowing to call connect just once.
-            throw new Error('Can not re-use ImapFlow instance');
+            let err = new Error('Can not re-use ImapFlow instance');
+            err.code = 'InstanceReused';
+            throw err;
         }
         this._connectCalled = true;
+        let closedError = () => this.createNoConnectionError(this.byeReason, { rejectedFrom: 'connect' });
+        // close() already ran, so there is no connection to set up and nothing would ever
+        // settle a connect attempt started now.
+        if (this.isClosed) {
+            throw closedError();
+        }
         // One deadline for the whole attempt, started before anything is resolved or negotiated.
         // Proxy DNS and proxy negotiation used to run entirely outside the timer, so a stalled
         // proxy could hang far beyond the documented connectionTimeout.
@@ -1931,9 +1946,20 @@ export class ImapFlow extends EventEmitter {
                 error._err = err;
                 throw error;
             }
+            // close() during proxy setup found no socket to destroy and no connect to reject,
+            // so the tunnel that just opened is dropped here instead of being handed to a
+            // closed client.
+            if (this.isClosed) {
+                socket.destroy();
+                throw closedError();
+            }
         }
         // Guarded: close() rejects a pending connect() synchronously. See guardedPromise().
         let connectPromise = guardedPromise((resolve, reject) => {
+            // Stored before the transport is up, so a close() that lands before onConnect
+            // still rejects this attempt through closeConnectSteps().
+            this.initialResolve = resolve;
+            this.initialReject = reject;
             // Whatever the proxy phase already used is gone from the budget
             this.connectTimeout = setTimeout(() => {
                 let err = deadline.error();
@@ -1985,9 +2011,6 @@ export class ImapFlow extends EventEmitter {
                     this.setSocketHandlers();
                     this.setEventHandlers();
                     connected.pipe(this.streamer);
-                    // executed by initial "* OK"
-                    this.initialResolve = resolve;
-                    this.initialReject = reject;
                     /* c8 ignore next 4 */ // defensive: the onConnect setup body does not throw under normal operation
                 }
                 catch (ex) {
@@ -2171,7 +2194,10 @@ export class ImapFlow extends EventEmitter {
             this._upgradeReject = null;
             reject(this.createNoConnectionError(false, { rejectedFrom: 'upgrade' }));
         }
-        if (typeof this.initialReject === 'function' && !this.options.verifyOnly) {
+        // A verifyOnly session closes itself with LOGOUT and startSession() settles connect()
+        // with the outcome, so the close is not a failure there. Before the greeting nothing
+        // else can settle it (BYE greeting, FIN, close() while the transport is still coming up).
+        if (typeof this.initialReject === 'function' && (!this.options.verifyOnly || !this.greetingReceived)) {
             clearTimer(this.greetingTimeout);
             let reject = this.initialReject;
             this.initialResolve = false;
@@ -2482,7 +2508,26 @@ export class ImapFlow extends EventEmitter {
      * // 125
      */
     async mailboxOpen(path, options) {
-        return await this.run('SELECT', path, options);
+        try {
+            return await this.run('SELECT', path, options);
+        }
+        catch (err) {
+            if (err.responseStatus === 'NO') {
+                // SELECT failed with NO: verify whether the mailbox exists at all by running
+                // LIST. This sets mailboxMissing on the error so the caller can distinguish
+                // "doesn't exist" from other failures, for getMailboxLock() callers as well.
+                try {
+                    let folders = await this.run('LIST', '', normalizePath(this, path), { listOnly: true });
+                    if (!folders || !folders.length) {
+                        err.mailboxMissing = true;
+                    }
+                }
+                catch (E) {
+                    this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
+                }
+            }
+            throw err;
+        }
     }
     /**
      * Closes a previously opened mailbox
@@ -3184,20 +3229,7 @@ export class ImapFlow extends EventEmitter {
                     break; // Wait for this lock to be released
                 }
                 catch (err) {
-                    if (err.responseStatus === 'NO') {
-                        // SELECT failed with NO: verify whether the mailbox exists
-                        // at all by running LIST. This sets mailboxMissing on the error
-                        // so the caller can distinguish "doesn't exist" from other failures.
-                        try {
-                            let folders = await this.run('LIST', '', path, { listOnly: true });
-                            if (!folders || !folders.length) {
-                                err.mailboxMissing = true;
-                            }
-                        }
-                        catch (E) {
-                            this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
-                        }
-                    }
+                    // mailboxOpen() has already marked a missing mailbox (mailboxMissing)
                     this.log.trace({
                         msg: 'Failed to acquire mailbox lock',
                         path,
@@ -3288,12 +3320,14 @@ export class ImapFlow extends EventEmitter {
     }
     /** @internal */
     getLogger() {
-        let mainLogger = this.options.logger && typeof this.options.logger === 'object'
-            ? this.options.logger
-            : logger.child({
-                component: 'imap-connection',
-                cid: this.id
-            });
+        let mainLogger = {};
+        if (this.options.logger && typeof this.options.logger === 'object') {
+            mainLogger = this.options.logger;
+        }
+        else if (this.options.logger !== false) {
+            // {logger:false} never consults mainLogger, so it does not create the default logger
+            mainLogger = createConnectionLogger({ cid: this.id, logRaw: this.options.logRaw });
+        }
         let synteticLogger = {};
         let levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
         for (let level of levels) {
@@ -3349,7 +3383,8 @@ export class ImapFlow extends EventEmitter {
     }
     /**
      * Detaches sockets from the IMAP pipeline. Useful for upgrading the connection
-     * (e.g., STARTTLS) or transferring socket ownership.
+     * (e.g., STARTTLS) or transferring socket ownership. Call it while the connection is not
+     * idling: an IDLE in progress is not broken first, so the server still expects `DONE`.
      *
      * @returns Socket objects: `readSocket` is the read socket (inflated socket if compression is enabled, raw socket otherwise),
      *   `writeSocket` the write socket and `socket` the raw underlying socket (same as readSocket/writeSocket when compression is disabled)
@@ -3364,6 +3399,11 @@ export class ImapFlow extends EventEmitter {
         // compression is active, the PassThrough writeSocket - so the connection
         // is fully released to the caller.
         this.clearSocketHandlers();
+        // The socket now belongs to the caller. Marking the client unusable keeps
+        // auto-IDLE (armed now, or re-armed by a lock release or a finished download)
+        // and a later dispose from writing IDLE or LOGOUT onto it.
+        this.usable = false;
+        clearTimer(this.idleStartTimer);
         const readSocket = this._inflate || socket;
         const writeSocket = this.writeSocket || socket;
         // Defense-in-depth: when compression is active the raw socket is orphaned
@@ -3461,6 +3501,23 @@ export class ImapFlow extends EventEmitter {
  *     console.log(`${entry.cid} ${entry.msg}`);
  * });
  */
+// Installed outside the class body: a computed `[Symbol.asyncDispose]` key would turn into a
+// method named "undefined" on Node.js 20.0-20.3, which predate the symbol
+if (typeof Symbol.asyncDispose === 'symbol') {
+    ImapFlow.prototype[Symbol.asyncDispose] = async function () {
+        if (this.usable) {
+            try {
+                await this.logout();
+            }
+            catch (err) {
+                logConnectionError(this, 'LOGOUT failed while disposing', err);
+            }
+        }
+        // logout() already closes the connection; close() is idempotent and covers a client
+        // that never connected or whose logout was skipped
+        this.close();
+    };
+}
 // Both `import { ImapFlow } from 'imapflow'` and `import imapflow from 'imapflow'` work, the
 // latter matching the shape `require('imapflow')` has always had
 const imapflow = { ImapFlow, AuthenticationFailure };

package/dist/esm/logger.d.ts

@@ -1,3 +1,21 @@
-import pino from 'pino';
-declare const logger: pino.Logger<never, boolean>;
-export default logger;
+import { type Logger as PinoLogger } from 'pino';
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+export declare function getDefaultLogger(): PinoLogger;
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+export declare function createConnectionLogger(options: {
+    cid?: string | undefined;
+    logRaw?: boolean | undefined;
+}): PinoLogger;

package/dist/esm/logger.js

@@ -1,4 +1,34 @@
 import pino from 'pino';
-const logger = pino();
-logger.level = 'trace';
-export default logger;
+let logger = null;
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+export function getDefaultLogger() {
+    if (!logger) {
+        logger = pino({ level: 'info' });
+    }
+    return logger;
+}
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+export function createConnectionLogger(options) {
+    let child = getDefaultLogger().child({
+        component: 'imap-connection',
+        cid: options.cid
+    });
+    // Raw socket data is logged at trace level, so asking for it lowers the threshold
+    if (options.logRaw) {
+        child.level = 'trace';
+    }
+    return child;
+}

package/dist/esm/package-info.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "imapflow";
-export declare const version = "2.0.8";
+export declare const version = "2.1.1";
 export declare const homepage = "https://imapflow.com/";

package/dist/esm/package-info.js

@@ -1,4 +1,4 @@
 // Generated by scripts/build.js from package.json. Do not edit by hand.
 export const name = "imapflow";
-export const version = "2.0.8";
+export const version = "2.1.1";
 export const homepage = "https://imapflow.com/";

package/dist/esm/search-compiler.d.ts

@@ -9,7 +9,7 @@ export type SearchAttribute = ImapAttributeNode | SearchAttribute[];
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available

package/dist/esm/search-compiler.js

@@ -1,5 +1,5 @@
 /* eslint no-control-regex:0 */
-import { formatDate, formatFlag, canUseFlag, toValidDate, isRev2Active } from './tools.js';
+import { formatDate, formatFlag, toValidDate, isRev2Active } from './tools.js';
 /**
  * Sets a boolean flag in the IMAP search attributes.
  * Automatically handles UN- prefixing for falsy values.
@@ -88,6 +88,17 @@ let processDateField = (attributes, term, value) => {
 };
 // Pre-compiled regex for better performance
 const UNICODE_PATTERN = /[^\x00-\x7F]/;
+/**
+ * Throws a coded search compilation error.
+ *
+ * @param code - Error code, one of the ImapFlowErrorCode values
+ * @param message - Error message
+ */
+let fail = (code, message) => {
+    let error = new Error(message);
+    error.code = code;
+    throw error;
+};
 /**
  * Checks if a string contains Unicode characters.
  * Used to determine if CHARSET UTF-8 needs to be specified.
@@ -107,7 +118,7 @@ let isUnicodeString = (str) => {
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available
@@ -133,21 +144,29 @@ export const searchCompiler = (connection, query) => {
     const attributes = [];
     // Track if we need to specify UTF-8 charset
     let hasUnicode = false;
-    const mailbox = connection.mailbox;
     /**
      * Recursively walks through the query object and builds IMAP attributes.
      * @param params - Query parameters to process
      */
     const walk = (params) => {
-        // Walks a query object and wraps the resulting attributes in a
-        // sub-array so the IMAP compiler emits parentheses around them.
-        // Used when a single search-key is required (NOT, OR operands)
-        // but the condition has multiple keys (RFC 3501 Section 6.4.4).
-        let walkGrouped = (obj) => {
+        // Compiles one NOT or OR operand, which the caller has already put its operator in
+        // front of. An operand with several keys is wrapped in a sub-array so the IMAP compiler
+        // emits parentheses around it, as the operator takes a single search-key
+        // (RFC 3501 Section 6.4.4). An operand that compiles to nothing (an invalid date, an
+        // empty object, ...) is refused: the operator would otherwise bind to whatever
+        // criterion follows it and invert or widen the search.
+        let walkOperand = (operator, obj) => {
             let startIdx = attributes.length;
-            walk(obj);
-            let subAttrs = attributes.splice(startIdx);
-            attributes.push(subAttrs);
+            if (obj && typeof obj === 'object') {
+                walk(obj);
+            }
+            if (attributes.length === startIdx) {
+                fail('InvalidSearchQuery', `Search operand for ${operator} does not include any usable search criteria`);
+            }
+            if (Object.keys(obj).length > 1) {
+                let subAttrs = attributes.splice(startIdx);
+                attributes.push(subAttrs);
+            }
         };
         Object.keys(params || {}).forEach(term => {
             switch (term.toUpperCase()) {
@@ -193,9 +212,7 @@ export const searchCompiler = (connection, query) => {
                         // reject the whole search with a tagged BAD, so fail with a
                         // descriptive error instead
                         if (isRev2Active(connection)) {
-                            let error = new Error(`The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
-                            error.code = 'MissingServerExtension';
-                            throw error;
+                            fail('MissingServerExtension', `The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
                         }
                         setBoolOpt(attributes, term, true);
                     }
@@ -241,6 +258,11 @@ export const searchCompiler = (connection, query) => {
                         // Fallback to Gmail message ID
                         setOpt(attributes, 'X-GM-MSGID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for EMAILID');
+                    }
                     break;
                 // Thread ID support (OBJECTID or Gmail extension)
                 case 'THREADID':
@@ -251,6 +273,11 @@ export const searchCompiler = (connection, query) => {
                         // Fallback to Gmail thread ID
                         setOpt(attributes, 'X-GM-THRID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for THREADID');
+                    }
                     break;
                 // Gmail raw search
                 case 'GMRAW':
@@ -262,9 +289,7 @@ export const searchCompiler = (connection, query) => {
                         setOpt(attributes, 'X-GM-RAW', params[term]);
                     }
                     else {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
                     }
                     break;
                 // Gmail label search. Compiles { has, not } into an X-GM-RAW "label:"/"-label:" query
@@ -298,9 +323,7 @@ export const searchCompiler = (connection, query) => {
                         break;
                     }
                     if (!connection.capabilities.has('X-GM-EXT-1')) {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for label search');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for label search');
                     }
                     let rawQuery = rawParts.join(' ');
                     if (isUnicodeString(rawQuery)) {
@@ -344,8 +367,10 @@ export const searchCompiler = (connection, query) => {
                 case 'UNKEYWORD':
                     {
                         let flag = formatFlag(params[term]);
-                        // Only add if flag is supported or already exists in mailbox
-                        if (canUseFlag(mailbox, flag) || mailbox.flags.has(flag)) {
+                        // Compiled even when the mailbox does not allow the keyword: the
+                        // correct answer is then the empty set, which dropping the
+                        // criterion would turn into every message matching the rest
+                        if (flag) {
                             setOpt(attributes, term, flag);
                         }
                     }
@@ -374,12 +399,7 @@ export const searchCompiler = (connection, query) => {
                 case 'NOT':
                     if (params[term] && typeof params[term] === 'object') {
                         attributes.push({ type: 'ATOM', value: 'NOT' });
-                        if (Object.keys(params[term]).length > 1) {
-                            walkGrouped(params[term]);
-                        }
-                        else {
-                            walk(params[term]);
-                        }
+                        walkOperand('NOT', params[term]);
                     }
                     break;
                 // OR operator - complex logic for building OR trees
@@ -438,14 +458,7 @@ export const searchCompiler = (connection, query) => {
                                 entry.forEach(walkOrTree);
                                 return;
                             }
-                            if (entry && typeof entry === 'object') {
-                                if (Object.keys(entry).length > 1) {
-                                    walkGrouped(entry);
-                                }
-                                else {
-                                    walk(entry);
-                                }
-                            }
+                            walkOperand('OR', entry);
                         };
                         walkOrTree(genOrTree(params[term]));
                     }

package/dist/esm/tools.d.ts

@@ -1,6 +1,6 @@
 import type { Transform } from 'node:stream';
 import type { ImapFlow } from './imap-flow.js';
-import type { ConnectionErrorSite, ImapFlowError } from './errors.js';
+import { type ConnectionErrorSite, type ImapFlowError } from './errors.js';
 import type { ImapAttributeList, ImapAttributeNode, ImapResponse } from './handler/types.js';
 import type { FetchMessageObject, ListResponse, ListTreeResponse, MailboxObject, MessageEnvelopeObject, MessageStructureObject, ImapFlowEvents, StatusQuery } from './types.js';
 export { AuthenticationFailure } from './errors.js';

package/dist/esm/tools.js

@@ -5,10 +5,11 @@ import { compiler } from './handler/imap-handler.js';
 import { createHash } from 'node:crypto';
 import { JPDecoder } from './jp-decoder.js';
 import iconv from 'iconv-lite';
+import { ImapFlowErrorCode } from './errors.js';
 export { AuthenticationFailure } from './errors.js';
 const FLAG_COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'grey'];
 // Error codes that only mean the connection is no longer usable. See logConnectionError().
-const CONNECTION_GONE_CODES = new Set(['NoConnection', 'EConnectionClosed', 'StateLogout']);
+const CONNECTION_GONE_CODES = new Set([ImapFlowErrorCode.NoConnection, ImapFlowErrorCode.EConnectionClosed, ImapFlowErrorCode.StateLogout]);
 // Upper bound for expanding server-supplied sequence ranges (see expandRange). 2^24
 // entries in total is far beyond any legitimate mailbox while keeping the worst-case
 // expansion of a hostile range set bounded.
@@ -760,11 +761,18 @@ export async function formatMessageResponse(untagged, mailbox) {
             case 'flags':
                 map.flags = new Set(getArray(attribute));
                 break;
+            // A server with nothing to report can answer ENVELOPE NIL or BODYSTRUCTURE NIL.
+            // The field is left unset then: parsing NIL threw, and the whole message
+            // disappeared from the FETCH result.
             case 'envelope':
-                map.envelope = parseEnvelope(attribute);
+                if (Array.isArray(attribute)) {
+                    map.envelope = parseEnvelope(attribute);
+                }
                 break;
             case 'bodystructure':
-                map.bodyStructure = parseBodystructure(attribute);
+                if (Array.isArray(attribute)) {
+                    map.bodyStructure = parseBodystructure(attribute);
+                }
                 break;
             case 'internaldate': {
                 let value = getString(attribute);
@@ -1092,7 +1100,7 @@ export function parseBodystructure(entry) {
             curNode.type = 'multipart/' + ((node[i++] || {}).value || '').toString().toLowerCase();
             // extension data (not available for BODY requests)
             // body parameter parenthesized list
-            if (i < node.length - 1) {
+            if (i < node.length) {
                 if (node[i]) {
                     curNode.parameters = getStructuredParams(node[i]);
                 }
@@ -1174,7 +1182,7 @@ export function parseBodystructure(entry) {
             }
             // extension data (not available for BODY requests)
             // md5
-            if (i < node.length - 1) {
+            if (i < node.length) {
                 if (node[i]) {
                     curNode.md5 = (node[i].value || '').toString().toLowerCase();
                 }
@@ -1184,7 +1192,7 @@ export function parseBodystructure(entry) {
         // the following are shared extension values (for both multipart and non-multipart parts)
         // not available for BODY requests
         // body disposition
-        if (i < node.length - 1) {
+        if (i < node.length) {
             let disposition = node[i];
             if (Array.isArray(disposition) && disposition.length) {
                 curNode.disposition = ((disposition[0] && disposition[0].value) || '').toString().toLowerCase();
@@ -1195,7 +1203,7 @@ export function parseBodystructure(entry) {
             i++;
         }
         // body language
-        if (i < node.length - 1) {
+        if (i < node.length) {
             if (node[i]) {
                 /* c8 ignore next */ // node[i] is truthy inside this guard, so the [] fallback is unreachable
                 curNode.language = [].concat(node[i] || []).map(val => ((val && val.value) || '').toString().toLowerCase());
@@ -1205,7 +1213,7 @@ export function parseBodystructure(entry) {
         // body location
         // NB! defined as a "string list" in RFC3501 but replaced in errata document with "string"
         // Errata: http://www.rfc-editor.org/errata_search.php?rfc=3501
-        if (i < node.length - 1) {
+        if (i < node.length) {
             if (node[i]) {
                 curNode.location = (node[i].value || '').toString();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "2.0.8",
+    "version": "2.1.1",
     "description": "IMAP Client for Node",
     "type": "module",
     "main": "./dist/cjs/imap-flow.js",
@@ -78,14 +78,14 @@
         "types-node-legacy": "npm:@types/node@20.0.0",
         "typescript": "6.0.3",
         "typescript-eslint": "8.70.1",
-        "wrangler": "4.141.0"
+        "wrangler": "4.142.0"
     },
     "dependencies": {
-        "@zone-eu/mailsplit": "5.4.17",
+        "@zone-eu/mailsplit": "5.4.18",
         "encoding-japanese": "2.4.0",
         "iconv-lite": "0.7.3",
         "libbase64": "1.3.0",
-        "libmime": "5.4.4",
+        "libmime": "5.4.5",
         "libqp": "2.1.1",
         "pino": "10.3.1",
         "socks": "2.8.10"