imapflow 2.2.6 → 2.2.7

package/dist/esm/commands/list.js

@@ -375,6 +375,15 @@ export default async function list(connection, reference, mailbox, options) {
         // Subscribed-only mailboxes that weren't in LIST are intentionally ignored
         // (they may be phantom entries from old subscriptions to deleted mailboxes).
         let runLsub = async () => {
+            // LIST has completed, so its entries are indexed once instead of searched per LSUB
+            // response, which was quadratic in the folder count. The first entry for a path wins,
+            // as with the linear search it replaces
+            let entriesByPath = new Map();
+            for (let entry of entries) {
+                if (!entriesByPath.has(entry.path)) {
+                    entriesByPath.set(entry.path, entry);
+                }
+            }
             let response = await connection.exec('LSUB', [encodePath(connection, normalizedReference), encodePath(connection, normalizedMailbox)], {
                 untagged: {
                     LSUB: async (untagged) => {
@@ -400,7 +409,7 @@ export default async function list(connection, reference, mailbox, options) {
                         entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
                         // Merge LSUB data into existing LIST entry if found
-                        let existing = entries.find(existing => existing.path === entry.path);
+                        let existing = entriesByPath.get(entry.path);
                         if (existing) {
                             existing.subscribed = true;
                             // Merge any additional flags from LSUB into the LIST entry

package/dist/esm/commands/login.js

@@ -1,4 +1,4 @@
-import { getStatusCode, getErrorText } from '../tools.js';
+import { getStatusCode, getErrorText, isServerRefusal } from '../tools.js';
 /**
  * Authenticates user using the IMAP LOGIN command.
  *
@@ -30,7 +30,11 @@ export default async function login(connection, username, password) {
         if (errorCode) {
             err.serverResponseCode = errorCode;
         }
-        err.authenticationFailed = true;
+        // Only a tagged NO/BAD is the server refusing the credentials; a lost connection or a
+        // timeout during LOGIN says nothing about them, and a caller may retry it
+        if (isServerRefusal(err)) {
+            err.authenticationFailed = true;
+        }
         err.response = await getErrorText(err.response);
         throw err;
     }

package/dist/esm/commands/logout.js

@@ -1,3 +1,7 @@
+import { clearTimer } from '../tools.js';
+// How long to wait for the server to answer LOGOUT before closing the socket anyway. Without a
+// bound of its own, an unanswered LOGOUT kept logout() pending until the socket timeout.
+const LOGOUT_TIMEOUT = 10 * 1000;
 /**
  * Logs out the user and closes the connection.
  *
@@ -16,6 +20,8 @@ export default async function logout(connection) {
         return false;
     }
     let response;
+    // close() rejects the pending LOGOUT with NoConnection, which counts as a completed logout
+    let timer = setTimeout(() => connection.close(), LOGOUT_TIMEOUT);
     try {
         response = await connection.exec('LOGOUT');
         return true;
@@ -33,6 +39,7 @@ export default async function logout(connection) {
         // Set state to LOGOUT before closing to prevent any further commands from
         // being queued. The socket is closed unconditionally in this finally block
         // regardless of whether the LOGOUT command succeeded or failed.
+        clearTimer(timer);
         connection.state = connection.states.LOGOUT;
         if (response && typeof response.next === 'function') {
             response.next();

package/dist/esm/commands/namespace.js

@@ -31,7 +31,8 @@ export default async function namespace(connection) {
     }
     let response;
     try {
-        let map = {};
+        // NIL personal namespaces and a missing NAMESPACE response leave the defaults in place
+        let map = { personal: [], other: false, shared: false };
         response = await connection.exec('NAMESPACE', false, {
             untagged: {
                 // The NAMESPACE response (RFC 2342) contains exactly three sections:
@@ -43,19 +44,22 @@ export default async function namespace(connection) {
                     if (!untagged.attributes || !untagged.attributes.length) {
                         return;
                     }
-                    map.personal = getNamsepaceInfo(untagged.attributes[0]);
+                    // NIL personal namespaces are legal (RFC 2342 section 5, e.g. after an anonymous login)
+                    map.personal = getNamsepaceInfo(untagged.attributes[0]) || [];
                     map.other = getNamsepaceInfo(untagged.attributes[1]);
                     map.shared = getNamsepaceInfo(untagged.attributes[2]);
                 }
             }
         });
+        // Release the response before touching the parsed data, so nothing below can leave the
+        // reader parked behind this command
+        response.next();
         connection.namespaces = map;
         // make sure that we have the first personal namespace always set
         if (!connection.namespaces.personal[0]) {
             connection.namespaces.personal[0] = { prefix: '', delimiter: '.' };
         }
         connection.namespaces.personal[0].prefix = connection.namespaces.personal[0].prefix || '';
-        response.next();
         connection.namespace = connection.namespaces.personal[0];
         return connection.namespace;
     }

package/dist/esm/commands/quota.js

@@ -11,7 +11,9 @@ export default async function quota(connection, path) {
         // nothing to do here
         return;
     }
-    if (!connection.capabilities.has('QUOTA')) {
+    // An RFC 9208 server advertises its QUOTA=RES-* resource types and does not have to list
+    // the bare RFC 2087 QUOTA token as well
+    if (!connection.capabilities.has('QUOTA') && ![...connection.capabilities.keys()].some(capability => capability.startsWith('QUOTA=RES-'))) {
         return false;
     }
     path = normalizePath(connection, path);

package/dist/esm/commands/rename.js

@@ -21,7 +21,8 @@ export default async function rename(connection, path, newPath) {
     // as IMAP servers will not rename an active mailbox.
     let selected = getSelectedMailbox(connection);
     if (selected && selected.path === path) {
-        await connection.run('CLOSE');
+        // UNSELECT where possible, CLOSE would expunge messages flagged \Deleted
+        await connection.run('CLOSE', { unselect: true });
     }
     let response;
     try {

package/dist/esm/commands/select.js

@@ -226,6 +226,11 @@ export default async function select(connection, pathInput, options) {
         if (!currentMailbox || currentMailbox.path !== path) {
             emitSafe(connection, 'mailboxOpen', connection.mailbox);
         }
+        else if (typeof map.exists === 'number' && map.exists !== currentMailbox.exists) {
+            // A re-SELECT of the open mailbox (the SELECT polling fallback) gets its EXISTS here
+            // instead of in the global handler, so it is reported the same way
+            emitSafe(connection, 'exists', { path, count: map.exists, prevCount: currentMailbox.exists });
+        }
         response.next();
         return map;
     }

package/dist/esm/commands/status.js

@@ -1,4 +1,4 @@
-import { encodePath, normalizePath, buildStatusQueryAttributes, isRev2Active, isAuthenticatedState, emitSafe, getSelectedMailbox } from '../tools.js';
+import { encodePath, normalizePath, buildStatusQueryAttributes, isRev2Active, isAuthenticatedState, emitSafe, getSelectedMailbox, logConnectionError } from '../tools.js';
 import { parseStatusList } from './status-fields.js';
 // STATUS fields that also refresh the live mailbox state when the queried mailbox is the
 // currently selected one. Keyed by the output property name parseStatusList() reports.
@@ -89,7 +89,12 @@ export default async function status(connection, path, query) {
         // Not a deadlock, and only reachable when the server rejects the STATUS, but a polled
         // STATUS of a missing folder ends the poll early.
         if (err.responseStatus === 'NO') {
-            let folders = await connection.run('LIST', '', path, { listOnly: true });
+            // A failing probe (lost connection, throttling) answers nothing about the mailbox,
+            // so STATUS then fails the same way as any other failed STATUS
+            let folders = await connection.run('LIST', '', path, { listOnly: true }).catch((listErr) => {
+                logConnectionError(connection, 'Failed to check if the mailbox exists', listErr);
+                return false;
+            });
             if (folders && !folders.length) {
                 let error = new Error(`Mailbox doesn't exist: ${path}`);
                 error.code = 'NotFound';

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

@@ -16,4 +16,4 @@ export interface StoreCommandOptions extends StoreOptions {
  * @param options - Store options
  * @returns True on success, false on failure or if nothing to do
  */
-export default function store(connection: ImapFlow, range: string, flags: string | string[], options: StoreCommandOptions): Promise<boolean>;
+export default function store(connection: ImapFlow, range: string, flags: string | string[], options?: StoreCommandOptions | undefined): Promise<boolean>;

package/dist/esm/commands/store.js

@@ -9,13 +9,12 @@ import { formatFlag, canUseFlag, reportCommandError, getSelectedMailbox } from '
  * @returns True on success, false on failure or if nothing to do
  */
 export default async function store(connection, range, flags, options) {
+    options = options || {};
     let mailbox = getSelectedMailbox(connection);
     if (!mailbox || !range || (options.useLabels && !connection.capabilities.has('X-GM-EXT-1'))) {
         // nothing to do here
         return false;
     }
-    /* c8 ignore next */ // options.useLabels is dereferenced in the guard above, so options is always defined here
-    options = options || {};
     // Build the IMAP STORE operation name. The format is:
     //   [+|-]FLAGS[.SILENT] or [+|-]X-GM-LABELS
     // Where: no prefix = replace all, + = add, - = remove

package/dist/esm/download.js

@@ -8,6 +8,9 @@ import libbase64 from 'libbase64';
 import { Headers } from '@zone-eu/mailsplit';
 import FlowedDecoder from '@zone-eu/mailsplit/lib/flowed-decoder.js';
 import { LimitedPassthrough, normalizeByteLimit } from './limited-passthrough.js';
+// What a wait on the head stream listens for: it can take more input, it failed, or it went
+// away (a consumer destroying it closes it without a 'drain')
+const DRAIN_WAIT_EVENTS = ['drain', 'error', 'close'];
 import { getDecoder, isUnsafeKey } from './tools.js';
 /**
  * Implements ImapFlow.download(), see its documentation
@@ -47,7 +50,8 @@ export async function downloadMessage(client, range, part, options) {
             range = uid;
             downloadOptions.uid = true;
         }
-        if (!response.bodyStructure.childNodes) {
+        // bodyStructure is unset when the server sent BODYSTRUCTURE NIL
+        if (!response.bodyStructure?.childNodes) {
             // single text message
             part = 'TEXT';
         }
@@ -290,11 +294,54 @@ export async function downloadMessage(client, range, part, options) {
     // at the bound still gets its terminating chunk. Infinity when the server reported no
     // size, which leaves the loop bounded by maxBytes alone.
     let maxTotalBytes = normalizeByteLimit(meta.expectedSize ? meta.expectedSize * 2 + chunkSize : 0);
-    // Fetch remaining chunks in a loop, writing each to the decoder stream.
-    // Stops when the server returns a short chunk (< chunkSize), answers with more than the
-    // requested window, the byte limiter is satisfied, or the consumer destroys the output
-    // stream. Throws when the ceiling above is crossed.
-    let fetchAllParts = async () => {
+    // Resolves once the head stream can take more input, rejects when it fails, and resolves
+    // when it goes away. finish() is the listener itself: 'drain' and 'close' emit no arguments,
+    // 'error' emits the error, and removal needs no separate handler references. It removes
+    // only the listeners this wait installed - removeAllListeners('error') also took off the
+    // forwarder pipeStage() attached to the head stream when the pipeline was built, and the
+    // head must keep that forwarder for the life of the download or a chunk failure has nowhere
+    // to go.
+    let waitForDrain = () => new Promise((resolve, reject) => {
+        const finish = (err) => {
+            for (let event of DRAIN_WAIT_EVENTS) {
+                stream.removeListener(event, finish);
+            }
+            /* c8 ignore next 2 */ // stream error during a backpressure drain wait is timing-dependent
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        };
+        for (let event of DRAIN_WAIT_EVENTS) {
+            stream.once(event, finish);
+        }
+    });
+    // Writes a chunk and waits out the backpressure. A base64 decoder defers its write callback,
+    // so a chunk the size of its buffer is never taken synchronously and the head chunk waits
+    // here as much as any other. A stream failure during the wait is thrown unless the download
+    // was already aborted (the consumer destroyed the stream).
+    let writeAndDrain = async (chunk) => {
+        if (writeChunk(chunk) !== false) {
+            return;
+        }
+        try {
+            await waitForDrain();
+            /* c8 ignore next 5 */ // re-throw path only triggers on a stream error mid-drain, which is timing-dependent
+        }
+        catch (err) {
+            if (!fetchAborted) {
+                throw err;
+            }
+        }
+    };
+    // Writes the head chunk, then fetches the remaining chunks in a loop, writing each to the
+    // decoder stream. Stops when the server returns a short chunk (< chunkSize), answers with
+    // more than the requested window, the byte limiter is satisfied, or the consumer destroys
+    // the output stream. Throws when the ceiling above is crossed.
+    let fetchAllParts = async (head) => {
+        await writeAndDrain(head);
         while (hasMore && !isLimited() && !fetchAborted) {
             if (processed >= maxTotalBytes) {
                 // Loud on purpose. Everything written downstream by this point holds
@@ -307,7 +354,9 @@ export async function downloadMessage(client, range, part, options) {
                 throw err;
             }
             let { response, chunk } = await getNextPart();
-            if (fetchAborted) {
+            // A consumer that gave up while the chunk was in flight: its 'close' may still be a
+            // tick away from setting fetchAborted, so the stream's own flag is checked as well
+            if (fetchAborted || output.destroyed) {
                 break;
             }
             if (response === false) {
@@ -322,48 +371,7 @@ export async function downloadMessage(client, range, part, options) {
             if (!chunk) {
                 break;
             }
-            // Handle backpressure
-            if (writeChunk(chunk) === false) {
-                // Wait for drain event before continuing
-                try {
-                    await new Promise((resolve, reject) => {
-                        // finish() is the listener itself, as settle() is for the TLS upgrade:
-                        // 'drain' and 'close' emit no arguments, 'error' emits the error, and
-                        // removal needs no separate handler references. It removes only the
-                        // three listeners this wait installed - removeAllListeners('error')
-                        // also took off the forwarder pipeStage() attached to the head stream
-                        // when the pipeline was built, and the head must keep that forwarder
-                        // for the life of the download or a chunk failure has nowhere to go.
-                        const finish = (err) => {
-                            for (let event of ['drain', 'error', 'close']) {
-                                stream.removeListener(event, finish);
-                            }
-                            /* c8 ignore next 2 */ // stream error during a backpressure drain wait is timing-dependent
-                            if (err) {
-                                reject(err);
-                            }
-                            else {
-                                resolve();
-                            }
-                        };
-                        stream.once('drain', finish);
-                        stream.once('error', finish);
-                        stream.once('close', finish);
-                    });
-                    /* c8 ignore start */ // re-throw path only triggers on a stream error mid-drain, which is timing-dependent
-                }
-                catch (err) {
-                    // Re-throw only if not aborted
-                    if (!fetchAborted) {
-                        throw err;
-                    }
-                }
-                /* c8 ignore stop */
-                // Check if we should abort after waiting
-                if (fetchAborted) {
-                    break;
-                }
-            }
+            await writeAndDrain(chunk);
         }
     };
     // A download is a sequence of chunk FETCHes with a backpressure wait in between. Those
@@ -382,13 +390,10 @@ export async function downloadMessage(client, range, part, options) {
             client.autoidle();
         }
     };
-    // Kick off the download pipeline asynchronously. The first chunk was
-    // already fetched above (to get metadata); write it to the decoder
-    // stream and then fetch remaining chunks via fetchAllParts().
-    // setImmediate ensures the caller gets the {meta, content} return
-    // value before streaming begins.
-    let runFetchAllParts = () => {
-        fetchAllParts()
+    // Runs the download pipeline with the head chunk fetched above (for its metadata): it is
+    // written to the decoder stream and the remaining chunks follow
+    let runFetchAllParts = (head) => {
+        fetchAllParts(head)
             .catch(err => {
             if (!fetchAborted && stream && !stream.destroyed) {
                 stream.emit('error', err);
@@ -420,36 +425,8 @@ export async function downloadMessage(client, range, part, options) {
             // for a routine-looking connection code.
             .catch(err => client.log.error({ msg: 'Failed to fail the download stream', err, cid: client.id }));
     };
-    setImmediate(() => {
-        let writeResult;
-        try {
-            writeResult = writeChunk(chunk);
-        }
-        catch (err) {
-            stream.emit('error', err);
-            finishDownload();
-            /* c8 ignore next 3 */ // emitting the error above triggers cleanup (fetchAborted=true), so this end() guard is already false here
-            if (!fetchAborted && stream && !stream.destroyed) {
-                stream.end();
-            }
-            return;
-        }
-        /* c8 ignore next 9 */ // `stream` is piped to the limiter before this runs, so the head write drains synchronously and always returns true (verified for chunkSize up to 8MB); the drain-wait branch is unreachable
-        if (!writeResult) {
-            // Initial chunk filled the buffer, wait for drain
-            stream.once('drain', () => {
-                if (!fetchAborted) {
-                    runFetchAllParts();
-                }
-                else {
-                    finishDownload();
-                }
-            });
-        }
-        else {
-            runFetchAllParts();
-        }
-    });
+    // Deferred so the caller gets the {meta, content} return value before streaming begins
+    setImmediate(() => runFetchAllParts(chunk));
     return {
         meta,
         content: output
@@ -469,14 +446,16 @@ export async function downloadMessageParts(client, range, parts, options) {
         // no mailbox selected, nothing to do
         return {};
     }
-    let downloadOptions = Object.assign({
-        chunkSize: 64 * 1024,
-        maxBytes: Infinity
-    }, options || {});
+    let downloadOptions = options || {};
+    // Asked as a partial fetch so at most maxBytes of each part crosses the wire, and enforced
+    // again on the answer for servers that ignore the partial specifier
+    let maxBytes = normalizeByteLimit(downloadOptions.maxBytes);
     let query = { bodyParts: [] };
     for (let part of parts) {
         query.bodyParts.push(part + '.mime');
-        query.bodyParts.push(part);
+        // The partial specifier carries a 32-bit length (RFC 9051 "number"), so a cap beyond
+        // that is applied on the answer alone
+        query.bodyParts.push(maxBytes > 0xffffffff ? part : { key: part, start: 0, maxLength: maxBytes });
     }
     let response = await client.fetchOne(range, query, downloadOptions);
     if (!response || !response.bodyParts) {
@@ -494,6 +473,18 @@ export async function downloadMessageParts(client, range, parts, options) {
         if (keyParts.length === 1) {
             // content
             let key = keyParts[0];
+            if (content.length > maxBytes) {
+                // The server ignored the partial specifier and sent the whole part, the quirk
+                // download() tolerates the same way: keep what was asked for
+                client.log.warn({
+                    msg: 'Server returned more than the requested window, truncating the part',
+                    part: key,
+                    maxBytes,
+                    received: content.length,
+                    cid: client.id
+                });
+                content = content.subarray(0, maxBytes);
+            }
             if (!data[key]) {
                 data[key] = { content };
             }

package/dist/esm/handler/imap-compiler.js

@@ -19,6 +19,10 @@ const safeNumber = (value) => {
     let num = Math.round(Number(value));
     return Number.isSafeInteger(num) && num >= 0 ? num : 0;
 };
+// Log output stands in a placeholder for any value longer than this, so a log entry never
+// carries a copy of a large token (a message body, a long unquoted server token)
+const LOG_VALUE_LIMIT = 100;
+const logPlaceholder = (length, kind) => `"(* ${length}B ${kind} *)"`;
 // Characters that cannot appear in an IMAP quoted string: CR and LF terminate a
 // command line, and NUL is outside the CHAR production entirely. A value carrying
 // any of them has to be sent as a literal, so quoting it is never correct.
@@ -127,8 +131,8 @@ async function compiler(response, options) {
             return;
         }
         if (typeof node === 'string' || Buffer.isBuffer(node)) {
-            if (isLogging && node.length > 100) {
-                resp.push(emitEntry('"(* ' + node.length + 'B string *)"'));
+            if (isLogging && node.length > LOG_VALUE_LIMIT) {
+                resp.push(emitEntry(logPlaceholder(node.length, 'string')));
             }
             else {
                 resp.push(emitEntry(isLogging ? JSON.stringify(node.toString()) : quoteString(node.toString())));
@@ -147,7 +151,7 @@ async function compiler(response, options) {
         switch (node.type.toUpperCase()) {
             case 'LITERAL':
                 if (isLogging) {
-                    resp.push(emitEntry('"(* ' + node.value.length + 'B literal *)"'));
+                    resp.push(emitEntry(logPlaceholder(node.value.length, 'literal')));
                 }
                 else {
                     // The literal size marker counts octets - string values are written as
@@ -179,8 +183,8 @@ async function compiler(response, options) {
                 }
                 break;
             case 'STRING':
-                if (isLogging && node.value.length > 100) {
-                    resp.push(emitEntry('"(* ' + node.value.length + 'B string *)"'));
+                if (isLogging && node.value.length > LOG_VALUE_LIMIT) {
+                    resp.push(emitEntry(logPlaceholder(node.value.length, 'string')));
                 }
                 else {
                     val = (node.value || '').toString();
@@ -238,11 +242,16 @@ async function compiler(response, options) {
             case 'SECTION':
                 val = (node.value || '').toString();
                 if (!node.section || val) {
-                    // Verify the value contains only valid ATOM-CHAR characters.
-                    // Strip a leading backslash before checking (system flags like \Seen start with '\').
-                    // If any character fails verification, fall back to an IMAP quoted string
-                    // (JSON.stringify is used only for log output, where values are display-escaped).
-                    if (node.value === '' || imapFormalSyntax.verify(val.charAt(0) === '\\' ? val.slice(1) : val, imapFormalSyntax['ATOM-CHAR']()) >= 0) {
+                    if (isLogging && val.length > LOG_VALUE_LIMIT) {
+                        // A server can put a line's worth of bytes in one unquoted token
+                        val = logPlaceholder(val.length, 'atom');
+                    }
+                    else if (node.value === '' ||
+                        imapFormalSyntax.verify(val.charAt(0) === '\\' ? val.slice(1) : val, imapFormalSyntax['ATOM-CHAR']()) >= 0) {
+                        // An empty value, or one with a character outside ATOM-CHAR (checked
+                        // past a leading backslash, as system flags like \Seen carry one), goes
+                        // out as an IMAP quoted string. JSON.stringify is used only for log
+                        // output, where values are display-escaped.
                         val = isLogging ? JSON.stringify(val) : quoteString(val);
                     }
                     resp.push(emitEntry(val));

package/dist/esm/handler/limits.d.ts

@@ -2,6 +2,17 @@ import type { ImapFlowError } from '../errors.js';
 export declare const MAX_LITERAL_SIZE: number;
 export declare const MAX_LINE_SIZE: number;
 export declare const MAX_RESPONSE_SIZE: number;
+export declare const ERROR_CONTEXT_LENGTH = 1024;
+/**
+ * The input a parse error carries: a bounded prefix with the full length.
+ *
+ * @param input - The input that failed to parse
+ * @returns The bounded prefix and the full length
+ */
+export declare const boundedInput: (input: string) => {
+    input: string;
+    inputLength: number;
+};
 /**
  * Normalizes a configured size limit. A non-negative integer is honored as-is (including 0, which
  * means "reject anything non-empty"), and `Infinity` disables the limit; anything else falls back

package/dist/esm/handler/limits.js

@@ -17,6 +17,20 @@ export const MAX_LINE_SIZE = MAX_LITERAL_SIZE;
 // of exactly the maximum permitted size impossible to receive. Configuring both limits calls for
 // the same headroom - set maxResponseSize above maxLiteralSize, not equal to it.
 export const MAX_RESPONSE_SIZE = 2 * MAX_LITERAL_SIZE;
+// How much of the offending input a parse error carries along. The error travels whole into log
+// entries (pino copies every property of a logged error) and into the rejection of the command
+// the line belonged to, and the line can be as long as the configured line cap.
+export const ERROR_CONTEXT_LENGTH = 1024;
+/**
+ * The input a parse error carries: a bounded prefix with the full length.
+ *
+ * @param input - The input that failed to parse
+ * @returns The bounded prefix and the full length
+ */
+export const boundedInput = (input) => ({
+    input: input.slice(0, ERROR_CONTEXT_LENGTH),
+    inputLength: input.length
+});
 /**
  * Normalizes a configured size limit. A non-negative integer is honored as-is (including 0, which
  * means "reject anything non-empty"), and `Infinity` disables the limit; anything else falls back

package/dist/esm/handler/parser-instance.d.ts

@@ -21,6 +21,16 @@ export declare class ParserInstance {
      * @param options.literals - Pre-parsed literal values from the stream.
      */
     constructor(input?: Buffer | string | null | undefined, options?: ParserOptions | undefined);
+    /**
+     * The context a parse error carries: a bounded prefix of the input (and of the element that
+     * failed, when there is one) with their full lengths, and the position.
+     *
+     * @param element - The element that failed to parse
+     * @returns The context to attach to the error
+     */
+    errorContext(element?: string | undefined): {
+        [key: string]: unknown;
+    };
     /**
      * Extracts and returns the IMAP tag from the beginning of the response.
      * The tag is typically "*" for untagged responses, "+" for continuation requests,

package/dist/esm/handler/parser-instance.js

@@ -1,6 +1,7 @@
 /* eslint new-cap: 0 */
 import imapFormalSyntax from './imap-formal-syntax.js';
 import { TokenParser } from './token-parser.js';
+import { boundedInput } from './limits.js';
 /**
  * Parses a single IMAP response line into its structural components: tag, command,
  * and attributes. Handles status responses (OK, NO, BAD, PREAUTH, BYE) with their
@@ -21,6 +22,22 @@ export class ParserInstance {
         this.remainder = this.input;
         this.pos = 0;
     }
+    /**
+     * The context a parse error carries: a bounded prefix of the input (and of the element that
+     * failed, when there is one) with their full lengths, and the position.
+     *
+     * @param element - The element that failed to parse
+     * @returns The context to attach to the error
+     */
+    errorContext(element) {
+        let context = { ...boundedInput(this.input), pos: this.pos };
+        if (element !== undefined) {
+            let bounded = boundedInput(element);
+            context.element = bounded.input;
+            context.elementLength = bounded.inputLength;
+        }
+        return context;
+    }
     /**
      * Extracts and returns the IMAP tag from the beginning of the response.
      * The tag is typically "*" for untagged responses, "+" for continuation requests,
@@ -122,7 +139,7 @@ export class ParserInstance {
         if (/^\s/.test(this.remainder)) {
             let error = new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
             error.code = 'ParserError1';
-            error.parserContext = { input: this.input, pos: this.pos };
+            error.parserContext = this.errorContext();
             throw error;
         }
         if ((match = this.remainder.match(/^\s*[^\s]+(?=\s|$)/))) {
@@ -136,9 +153,7 @@ export class ParserInstance {
                     let error = new Error(`Server returned an error: ${this.input}`);
                     error.code = 'ParserErrorExchange';
                     error.parserContext = {
-                        input: this.input,
-                        element,
-                        pos: this.pos,
+                        ...this.errorContext(element),
                         value: {
                             tag: '*',
                             command: 'BAD',
@@ -149,14 +164,14 @@ export class ParserInstance {
                 }
                 let error = new Error(`Unexpected char at position ${this.pos + errPos} [E2: ${JSON.stringify(element.charAt(errPos))}]`);
                 error.code = 'ParserError2';
-                error.parserContext = { input: this.input, element, pos: this.pos };
+                error.parserContext = this.errorContext(element);
                 throw error;
             }
         }
         else {
             let error = new Error(`Unexpected end of input at position ${this.pos} [E3]`);
             error.code = 'ParserError3';
-            error.parserContext = { input: this.input, pos: this.pos };
+            error.parserContext = this.errorContext();
             throw error;
         }
         this.pos += match[0].length;
@@ -177,13 +192,13 @@ export class ParserInstance {
             }
             let error = new Error(`Unexpected end of input at position ${this.pos} [E4]`);
             error.code = 'ParserError4';
-            error.parserContext = { input: this.input, pos: this.pos };
+            error.parserContext = this.errorContext();
             throw error;
         }
         if (imapFormalSyntax.verify(this.remainder.charAt(0), imapFormalSyntax.SP()) >= 0) {
             let error = new Error(`Unexpected char at position ${this.pos} [E5: ${JSON.stringify(this.remainder.charAt(0))}]`);
             error.code = 'ParserError5';
-            error.parserContext = { input: this.input, element: this.remainder, pos: this.pos };
+            error.parserContext = this.errorContext(this.remainder);
             throw error;
         }
         this.pos++;
@@ -201,13 +216,13 @@ export class ParserInstance {
         if (!this.remainder.length) {
             let error = new Error(`Unexpected end of input at position ${this.pos} [E6]`);
             error.code = 'ParserError6';
-            error.parserContext = { input: this.input, pos: this.pos };
+            error.parserContext = this.errorContext();
             throw error;
         }
         if (/^\s/.test(this.remainder)) {
             let error = new Error(`Unexpected whitespace at position ${this.pos} [E7]`);
             error.code = 'ParserError7';
-            error.parserContext = { input: this.input, element: this.remainder, pos: this.pos };
+            error.parserContext = this.errorContext(this.remainder);
             throw error;
         }
         const tokenParser = new TokenParser(this, this.pos, this.remainder, this.options);