imapflow 1.7.8 → 2.0.0

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

@@ -0,0 +1,285 @@
+"use strict";
+/* eslint no-console: 0, new-cap: 0 */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const imap_formal_syntax_js_1 = __importDefault(require("./imap-formal-syntax.js"));
+// A single element of a sequence-set as defined by the RFC 9051 grammar: a number
+// or a range, where "*" stands for the largest number in use. Digit strings are not
+// range-checked here (a server rejects "0" or an overlong number on its own); the
+// point of the check is that nothing outside this alphabet can reach the wire.
+const SEQ_RANGE = /^(\d+|\*)(:(\d+|\*))?$/;
+// Validates a full sequence-set: comma-separated SEQ_RANGE elements, or "$"
+// (RFC 5182 SEARCHRES), which references the previous SEARCH result and is only
+// valid as the entire set. Split into per-element tests on purpose - a whole-set
+// regex with an unbounded repeat group overflows the regex engine's backtrack
+// stack with an uncoded RangeError on valid sets in the million-element range,
+// while the per-element regex is bounded.
+const isValidSequenceSet = (value) => value === '$' || value.split(',').every(part => SEQ_RANGE.test(part));
+// Numeric tokens may only put the digit alphabet on the wire. Anything that does
+// not round to a bounded non-negative integer (NaN, Infinity, negatives, unsafe
+// magnitudes) degrades to 0 - the fallback the NaN coercion has always used.
+const safeNumber = (value) => {
+    let num = Math.round(Number(value));
+    return Number.isSafeInteger(num) && num >= 0 ? num : 0;
+};
+// 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.
+const NOT_QUOTABLE = /[\r\n\0]/;
+// A line terminator ends an IMAP command, so no token may carry one to the wire.
+const CRLF = /[\r\n]/;
+/**
+ * Quotes a value as an IMAP quoted string. Only DQUOTE and backslash are escaped -
+ * the IMAP grammar defines no other escape sequence, so JSON-style escaping (which
+ * turns a tab into a literal backslash-t and a control character into \\uXXXX) would
+ * silently change the value the server receives.
+ *
+ * @param value - The value to quote.
+ * @returns The quoted string, ready to be written to the wire.
+ * @throws {Error} If the value contains CR, LF or NUL, which a quoted string cannot carry.
+ */
+const quoteString = (value) => {
+    if (NOT_QUOTABLE.test(value)) {
+        let error = new Error('Unquotable character in IMAP string value');
+        error.code = 'InvalidStringValue';
+        throw error;
+    }
+    return '"' + value.replace(/["\\]/g, char => '\\' + char) + '"';
+};
+async function compiler(response, options) {
+    let { asArray, isLogging, literalPlus, literalMinus } = options || {};
+    const respParts = [];
+    // Formats an entry (string, number or Buffer) into the Buffer that is written to
+    // the wire, and is the choke point every emission passes through: a line
+    // terminator ends an IMAP command, so no token - the tag and command name
+    // included - may put one on the wire. The literal size marker and literal data
+    // are the only emissions where CRLF is legitimate; those call sites opt out with
+    // `raw`. Never enforced when logging: re-encoding an incoming server response for
+    // the log or for error text must not throw, whatever the server sent. With
+    // `returnEmpty`, an unrecognized entry type yields null instead of an empty
+    // Buffer.
+    const emitEntry = (entry, opts) => {
+        let { returnEmpty, raw } = opts || {};
+        if (!raw && !isLogging && (typeof entry === 'string' || Buffer.isBuffer(entry)) && CRLF.test(entry.toString('latin1'))) {
+            let error = new Error('Line terminator in IMAP token');
+            error.code = 'InvalidTokenValue';
+            throw error;
+        }
+        if (typeof entry === 'string') {
+            return Buffer.from(entry);
+        }
+        if (typeof entry === 'number') {
+            return Buffer.from(entry.toString());
+        }
+        if (Buffer.isBuffer(entry)) {
+            return entry;
+        }
+        if (returnEmpty) {
+            return null;
+        }
+        return Buffer.alloc(0);
+    };
+    let resp = []
+        .concat(emitEntry(response.tag, { returnEmpty: true }) || [])
+        .concat(response.command ? emitEntry(' ' + response.command) : []);
+    let val;
+    let lastType;
+    let walk = async (node, options) => {
+        options = options || {};
+        // Determine whether a space separator is needed before this node.
+        // Inspect the last byte written to decide context.
+        let lastRespEntry = resp.length && resp[resp.length - 1];
+        let lastRespByte = (lastRespEntry && lastRespEntry.length && lastRespEntry[lastRespEntry.length - 1]) || '';
+        if (typeof lastRespByte === 'number') {
+            lastRespByte = String.fromCharCode(lastRespByte);
+        }
+        // Add a space separator when:
+        // - The previous token was a LITERAL. Literal data ends exactly at its declared length, so
+        //   a following token always needs an explicit separator, even though the last written byte
+        //   is arbitrary literal content.
+        // - Otherwise: there is something written already (resp is not empty) and the last byte is
+        //   not an opening delimiter ('(', '<' or '['), which suppresses the space.
+        // A sub-array element in a consecutive-list context never gets one (no space between
+        // adjacent lists).
+        if (lastType === 'LITERAL' || (!['(', '<', '['].includes(lastRespByte) && resp.length)) {
+            if (!options.subArray) {
+                resp.push(emitEntry(' '));
+            }
+        }
+        if (node && node.buffer && !Buffer.isBuffer(node)) {
+            // mongodb binary
+            node = node.buffer;
+        }
+        if (Array.isArray(node)) {
+            lastType = 'LIST';
+            resp.push(emitEntry('('));
+            // check if we need to skip separator WS between two arrays
+            let subArray = node.length > 1 && Array.isArray(node[0]);
+            for (let child of node) {
+                if (subArray && !Array.isArray(child)) {
+                    subArray = false;
+                }
+                await walk(child, { subArray });
+            }
+            resp.push(emitEntry(')'));
+            return;
+        }
+        if (!node && typeof node !== 'string' && typeof node !== 'number' && !Buffer.isBuffer(node)) {
+            resp.push(emitEntry('NIL'));
+            return;
+        }
+        if (typeof node === 'string' || Buffer.isBuffer(node)) {
+            if (isLogging && node.length > 100) {
+                resp.push(emitEntry('"(* ' + node.length + 'B string *)"'));
+            }
+            else {
+                resp.push(emitEntry(isLogging ? JSON.stringify(node.toString()) : quoteString(node.toString())));
+            }
+            return;
+        }
+        if (typeof node === 'number') {
+            resp.push(emitEntry(safeNumber(node))); // Only bounded non-negative integers allowed
+            return;
+        }
+        lastType = node.type;
+        if (isLogging && node.sensitive) {
+            resp.push(emitEntry('"(* value hidden *)"'));
+            return;
+        }
+        switch (node.type.toUpperCase()) {
+            case 'LITERAL':
+                if (isLogging) {
+                    resp.push(emitEntry('"(* ' + node.value.length + 'B literal *)"'));
+                }
+                else {
+                    // The literal size marker counts octets - string values are written as
+                    // UTF-8, so their UTF-16 .length would undercount multi-byte characters
+                    let literalLength = !node.value ? 0 : Buffer.isBuffer(node.value) ? node.value.length : Buffer.byteLength(node.value.toString());
+                    // Append '+' to the size marker only when the extension actually permits a
+                    // non-synchronizing literal of this size (RFC 7888): LITERAL+ always,
+                    // LITERAL- only up to 4096 bytes
+                    let usePlus = literalPlus || (literalMinus && literalLength <= 4096);
+                    // canAppend: whether the literal data can be sent in the same buffer segment -
+                    // non-synchronizing literals always, and everything in single-buffer mode
+                    // (asArray false), which has no continuation flow
+                    let canAppend = !asArray || usePlus;
+                    // Emit the literal header: optional '~' prefix for literal8, then {size[+]}\r\n
+                    resp.push(emitEntry(`${node.isLiteral8 ? '~' : ''}{${literalLength}${usePlus ? '+' : ''}}\r\n`, { raw: true }));
+                    if (canAppend) {
+                        // Literal data follows immediately in the same buffer segment
+                        if (node.value && node.value.length) {
+                            resp.push(emitEntry(node.value, { raw: true }));
+                        }
+                    }
+                    else {
+                        // For synchronizing literals in asArray mode, split output into separate
+                        // parts. The caller must send each part and wait for a continuation
+                        // response from the server before sending the next.
+                        respParts.push(resp);
+                        resp = [].concat(emitEntry(node.value, { returnEmpty: true, raw: true }) || []);
+                    }
+                }
+                break;
+            case 'STRING':
+                if (isLogging && node.value.length > 100) {
+                    resp.push(emitEntry('"(* ' + node.value.length + 'B string *)"'));
+                }
+                else {
+                    val = (node.value || '').toString();
+                    resp.push(emitEntry(isLogging ? JSON.stringify(val) : quoteString(val)));
+                }
+                break;
+            case 'SEQUENCE':
+                // Sequence sets are written verbatim - they are the one token type with
+                // no quoting to fall back on. Callers build them from user-supplied
+                // ranges, so validate here, at the single point every outgoing sequence
+                // set passes through, rather than trusting each command module. Skipped
+                // when logging: the incoming token parser accepts sequence-shaped tokens
+                // this strict grammar rejects (an ESEARCH set like "1:2:3", a folder
+                // name like "12:30:00"), and re-compiling a server response for the log
+                // or for error text must never throw.
+                if (!isLogging && (typeof node.value === 'string' || typeof node.value === 'number' || Buffer.isBuffer(node.value))) {
+                    val = node.value.toString();
+                    if (val && !isValidSequenceSet(val)) {
+                        let error = new Error('Invalid sequence set value');
+                        error.code = 'InvalidSequenceSet';
+                        throw error;
+                    }
+                }
+                if (node.value) {
+                    // raw: the validated alphabet cannot contain a line terminator, and
+                    // re-scanning a potentially multi-megabyte set in the choke point
+                    // would double the cost of exactly the sets this branch exists for
+                    resp.push(emitEntry(node.value, { raw: true }));
+                }
+                break;
+            case 'TEXT':
+                // Response text is written verbatim. Only the parser produces it today, for
+                // incoming lines, so this is a re-encoding path rather than a command-building
+                // one. The emitEntry choke point would refuse a line terminator here too;
+                // this check runs first only to raise the more specific InvalidTextValue code.
+                if (node.value) {
+                    if (!isLogging && CRLF.test(node.value.toString())) {
+                        let error = new Error('Line terminator in IMAP text value');
+                        error.code = 'InvalidTextValue';
+                        throw error;
+                    }
+                    resp.push(emitEntry(node.value));
+                }
+                break;
+            case 'NUMBER':
+                // Coerced rather than written through: formatRespEntry passes a string or
+                // Buffer straight to the wire, so a numeric token carrying a string value
+                // would be another verbatim channel
+                resp.push(emitEntry(safeNumber(node.value)));
+                break;
+            case 'ATOM':
+            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 === '' || imap_formal_syntax_js_1.default.verify(val.charAt(0) === '\\' ? val.substr(1) : val, imap_formal_syntax_js_1.default['ATOM-CHAR']()) >= 0) {
+                        val = isLogging ? JSON.stringify(val) : quoteString(val);
+                    }
+                    resp.push(emitEntry(val));
+                }
+                // Section bracket handling: emit [section-contents] after the ATOM value
+                // e.g., BODY[HEADER.FIELDS (Subject)] or BODY[1.MIME]
+                if (node.section) {
+                    resp.push(emitEntry('['));
+                    for (let child of node.section) {
+                        await walk(child);
+                    }
+                    resp.push(emitEntry(']'));
+                }
+                // Partial range: emit <origin.length> after the section brackets. Coerced
+                // rather than joined as-is: this is the last token component written
+                // verbatim, and the choke point is only worth relying on if it holds for
+                // all of them. Every producer already passes numbers, so nothing changes
+                // for them.
+                if (node.partial) {
+                    resp.push(emitEntry(`<${node.partial.map(safeNumber).join('.')}>`));
+                }
+                break;
+        }
+    };
+    if (response.attributes) {
+        let attributes = Array.isArray(response.attributes) ? response.attributes : [].concat(response.attributes);
+        for (let child of attributes) {
+            await walk(child);
+        }
+    }
+    if (resp.length) {
+        respParts.push(resp);
+    }
+    const compiled = respParts.map(part => Buffer.concat(part));
+    return asArray ? compiled : compiled.flatMap(entry => entry);
+}
+exports.default = compiler;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/handler/imap-formal-syntax.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Verifies that every character in the given string is within the set of allowed characters.
+ *
+ * @param str - The string to validate.
+ * @param allowedChars - A string containing all allowed characters.
+ * @returns The index of the first disallowed character, or -1 if all characters are valid.
+ */
+declare function verify(str: string, allowedChars: string): number;
+declare const imapFormalSyntax: {
+    CHAR: () => string;
+    CHAR8: () => string;
+    SP: () => string;
+    CTL: () => string;
+    DQUOTE: () => string;
+    ALPHA: () => string;
+    DIGIT: () => string;
+    'ATOM-CHAR': () => string;
+    'ASTRING-CHAR': () => string;
+    'TEXT-CHAR': () => string;
+    'atom-specials': () => string;
+    'list-wildcards': () => string;
+    'quoted-specials': () => string;
+    'resp-specials': () => string;
+    tag: () => string;
+    command: () => string;
+    verify: typeof verify;
+};
+export default imapFormalSyntax;

package/dist/cjs/handler/imap-formal-syntax.js

@@ -0,0 +1,121 @@
+"use strict";
+/* eslint new-cap: 0, no-useless-concat: 0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Defines the IMAP formal syntax character classes and validation rules as specified
+ * in RFC 3501 Section 9 (http://tools.ietf.org/html/rfc3501#section-9).
+ *
+ * Each exported method returns a string of allowed characters for a given IMAP grammar
+ * production rule (e.g., ATOM-CHAR, ASTRING-CHAR, TEXT-CHAR). Results are computed once,
+ * on first use, and cached at module level.
+ *
+ * Also exports a `verify` function for validating strings against a set of allowed characters.
+ */
+/**
+ * Generates a string containing all characters in the given Unicode code point range (inclusive).
+ *
+ * @param start - The starting character code point.
+ * @param end - The ending character code point.
+ * @returns A string containing all characters from start to end.
+ */
+function expandRange(start, end) {
+    let chars = [];
+    for (let i = start; i <= end; i++) {
+        chars.push(i);
+    }
+    return String.fromCharCode(...chars);
+}
+/**
+ * Returns a new string with all characters from the exclude string removed from the source string.
+ *
+ * @param source - The source string to filter.
+ * @param exclude - A string of characters to exclude from the source.
+ * @returns The source string with excluded characters removed.
+ */
+function excludeChars(source, exclude) {
+    return Array.prototype.filter.call(source, (ch) => exclude.indexOf(ch) < 0).join('');
+}
+/**
+ * Wraps a computation so that it runs once, on first call, and the result is reused afterwards.
+ *
+ * @param compute - Produces the character set.
+ * @returns A zero-argument function returning the cached character set.
+ */
+function memo(compute) {
+    let value = null;
+    return () => {
+        if (value === null) {
+            value = compute();
+        }
+        return value;
+    };
+}
+/** All 7-bit US-ASCII characters excluding NUL (0x01-0x7F). */
+const CHAR = memo(() => expandRange(0x01, 0x7f));
+/** All 8-bit characters excluding NUL (0x01-0xFF). */
+const CHAR8 = memo(() => expandRange(0x01, 0xff));
+/** The space character (0x20). */
+const SP = () => ' ';
+/** All control characters (0x00-0x1F and 0x7F). */
+const CTL = memo(() => expandRange(0x00, 0x1f) + '\x7F');
+/** The double-quote character. */
+const DQUOTE = () => '"';
+/** All uppercase and lowercase ASCII alphabetic characters (A-Z, a-z). */
+const ALPHA = memo(() => expandRange(0x41, 0x5a) + expandRange(0x61, 0x7a));
+/** All ASCII digit characters (0-9). */
+const DIGIT = memo(() => expandRange(0x30, 0x39));
+/** The LIST wildcard characters ("%" and "*"). */
+const listWildcards = () => '%' + '*';
+/** Characters that are special inside quoted strings (DQUOTE and backslash). */
+const quotedSpecials = memo(() => DQUOTE() + '\\');
+/** The response-special character ("]"). */
+const respSpecials = () => ']';
+/** Characters that are special in ATOMs and must be excluded: "(", ")", "{", SP, CTL, list-wildcards, quoted-specials, resp-specials. */
+const atomSpecials = memo(() => '(' + ')' + '{' + SP() + CTL() + listWildcards() + quotedSpecials() + respSpecials());
+/** Characters allowed in an IMAP ATOM (CHAR minus atom-specials). */
+const atomChar = memo(() => excludeChars(CHAR(), atomSpecials()));
+/** Characters allowed in an IMAP ASTRING (ATOM-CHAR plus resp-specials). */
+const astringChar = memo(() => atomChar() + respSpecials());
+/** Characters allowed in IMAP text (CHAR minus CR and LF). */
+const textChar = memo(() => excludeChars(CHAR(), '\r\n'));
+/** Characters allowed in an IMAP tag (ASTRING-CHAR minus "+"). */
+const tag = memo(() => excludeChars(astringChar(), '+'));
+/** Characters allowed in an IMAP command name (ALPHA, DIGIT, and hyphen). */
+const command = memo(() => ALPHA() + DIGIT() + '-');
+/**
+ * Verifies that every character in the given string is within the set of allowed characters.
+ *
+ * @param str - The string to validate.
+ * @param allowedChars - A string containing all allowed characters.
+ * @returns The index of the first disallowed character, or -1 if all characters are valid.
+ */
+function verify(str, allowedChars) {
+    for (let i = 0, len = str.length; i < len; i++) {
+        if (allowedChars.indexOf(str.charAt(i)) < 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+const imapFormalSyntax = {
+    CHAR,
+    CHAR8,
+    SP,
+    CTL,
+    DQUOTE,
+    ALPHA,
+    DIGIT,
+    'ATOM-CHAR': atomChar,
+    'ASTRING-CHAR': astringChar,
+    'TEXT-CHAR': textChar,
+    'atom-specials': atomSpecials,
+    'list-wildcards': listWildcards,
+    'quoted-specials': quotedSpecials,
+    'resp-specials': respSpecials,
+    tag,
+    command,
+    verify
+};
+exports.default = imapFormalSyntax;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/handler/imap-handler.d.ts

@@ -0,0 +1,9 @@
+import parser from './imap-parser.js';
+import compiler from './imap-compiler.js';
+/**
+ * Re-exports the IMAP protocol parser and compiler as a single module.
+ *
+ * - `parser` parses raw IMAP command/response buffers into structured objects.
+ * - `compiler` compiles structured response objects into IMAP protocol Buffers.
+ */
+export { parser, compiler };

package/dist/cjs/handler/imap-handler.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compiler = exports.parser = void 0;
+const imap_parser_js_1 = __importDefault(require("./imap-parser.js"));
+exports.parser = imap_parser_js_1.default;
+const imap_compiler_js_1 = __importDefault(require("./imap-compiler.js"));
+exports.compiler = imap_compiler_js_1.default;

package/dist/cjs/handler/imap-parser.d.ts

@@ -0,0 +1,16 @@
+import type { ImapResponse, ParserOptions } from './types.js';
+/**
+ * Parses a raw IMAP command or response buffer into a structured object.
+ * Handles edge cases such as null-byte-padded responses from buggy servers and
+ * multi-word commands like UID and AUTHENTICATE.
+ *
+ * @param command - The raw IMAP command or response data to parse.
+ * @param options - Parser options passed through to the underlying ParserInstance and TokenParser.
+ * @param options.literalPlus - Whether the LITERAL+ extension is in use.
+ * @param options.literals - Pre-parsed literal values extracted from the input stream.
+ * @returns A promise that resolves to a parsed response object with `tag` (the IMAP tag, e.g. "*",
+ *   "+", or a command tag like "A1"), `command` (the IMAP command or response name, e.g. "OK",
+ *   "FETCH"), `attributes` (parsed attributes of the response) and `nullBytesRemoved` (number of
+ *   leading null bytes removed, if any).
+ */
+export default function parser(command: Buffer | string, options?: ParserOptions | undefined): Promise<ImapResponse>;

package/dist/cjs/handler/imap-parser.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parser;
+const imap_formal_syntax_js_1 = __importDefault(require("./imap-formal-syntax.js"));
+const parser_instance_js_1 = require("./parser-instance.js");
+/**
+ * Parses a raw IMAP command or response buffer into a structured object.
+ * Handles edge cases such as null-byte-padded responses from buggy servers and
+ * multi-word commands like UID and AUTHENTICATE.
+ *
+ * @param command - The raw IMAP command or response data to parse.
+ * @param options - Parser options passed through to the underlying ParserInstance and TokenParser.
+ * @param options.literalPlus - Whether the LITERAL+ extension is in use.
+ * @param options.literals - Pre-parsed literal values extracted from the input stream.
+ * @returns A promise that resolves to a parsed response object with `tag` (the IMAP tag, e.g. "*",
+ *   "+", or a command tag like "A1"), `command` (the IMAP command or response name, e.g. "OK",
+ *   "FETCH"), `attributes` (parsed attributes of the response) and `nullBytesRemoved` (number of
+ *   leading null bytes removed, if any).
+ */
+async function parser(command, options) {
+    options = options || {};
+    let nullBytesRemoved = 0;
+    // Workaround for buggy IMAP servers that pad responses with leading NUL (\x00) bytes.
+    // Some servers (observed in the wild) prepend null bytes to their output, which would
+    // cause parsing to fail. We strip them and note how many were removed for diagnostics.
+    if (command[0] === 0) {
+        // find the first non null byte and trim
+        let firstNonNull = -1;
+        for (let i = 0; i < command.length; i++) {
+            if (command[i] !== 0) {
+                firstNonNull = i;
+                break;
+            }
+        }
+        if (firstNonNull === -1) {
+            // All bytes are null, treat as a BAD response
+            return { tag: '*', command: 'BAD', attributes: [] };
+        }
+        command = command.slice(firstNonNull);
+        nullBytesRemoved = firstNonNull;
+    }
+    const parserInstance = new parser_instance_js_1.ParserInstance(command, options);
+    const response = {};
+    try {
+        response.tag = await parserInstance.getTag();
+        await parserInstance.getSpace();
+        response.command = await parserInstance.getCommand();
+        if (nullBytesRemoved) {
+            response.nullBytesRemoved = nullBytesRemoved;
+        }
+        // Some IMAP commands are multi-word: "UID FETCH", "UID STORE", "UID COPY",
+        // "UID MOVE", "UID SEARCH", "UID EXPUNGE", and "AUTHENTICATE PLAIN", etc.
+        // For these, the first word is consumed as the command, then we read the
+        // subcommand and concatenate them (e.g., "UID" + " " + "FETCH" -> "UID FETCH").
+        if (['UID', 'AUTHENTICATE'].includes((response.command || '').toUpperCase())) {
+            await parserInstance.getSpace();
+            response.command += ' ' + (await parserInstance.getElement(imap_formal_syntax_js_1.default.command()));
+        }
+        if (parserInstance.remainder.trim().length) {
+            await parserInstance.getSpace();
+            response.attributes = await parserInstance.getAttributes();
+        }
+        if (parserInstance.humanReadable) {
+            response.attributes = (response.attributes || []).concat({
+                type: 'TEXT',
+                value: parserInstance.humanReadable
+            });
+        }
+    }
+    catch (err) {
+        let error = err;
+        if (error.code === 'ParserErrorExchange' && error.parserContext && error.parserContext.value) {
+            return error.parserContext.value;
+        }
+        if (response.tag) {
+            // The tag had already been parsed when the rest of the line failed. Expose it
+            // so the connection can settle the command this line was addressed to - unlike
+            // re-deriving the tag from the raw bytes, this inherits the leading-NUL
+            // workaround above.
+            error.parsedTag = response.tag;
+        }
+        throw error;
+    }
+    return response;
+}
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });