imapflow 1.0.154 → 1.0.156

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.0.156](https://github.com/postalsys/imapflow/compare/v1.0.155...v1.0.156) (2024-03-07)
+
+
+### Bug Fixes
+
+* micro-optimizations for parser ([3451ad2](https://github.com/postalsys/imapflow/commit/3451ad235532ca1a64a829f9f2f8e77bcef3a17d))
+
+## [1.0.155](https://github.com/postalsys/imapflow/compare/v1.0.154...v1.0.155) (2024-03-06)
+
+
+### Bug Fixes
+
+* **exchange:** handle special error response from exchange ([3ed4198](https://github.com/postalsys/imapflow/commit/3ed4198c1b5504ab0b46926fec179c682988b2e3))
+
 ## [1.0.154](https://github.com/postalsys/imapflow/compare/v1.0.153...v1.0.154) (2024-03-05)
 
 

package/lib/handler/imap-parser.js

@@ -24,29 +24,37 @@ module.exports = async (command, options) => {
     const parser = new ParserInstance(command, options);
     const response = {};
 
-    response.tag = await parser.getTag();
-    await parser.getSpace();
-    response.command = await parser.getCommand();
+    try {
+        response.tag = await parser.getTag();
 
-    if (nullBytesRemoved) {
-        response.nullBytesRemoved = nullBytesRemoved;
-    }
-
-    if (['UID', 'AUTHENTICATE'].indexOf((response.command || '').toUpperCase()) >= 0) {
         await parser.getSpace();
-        response.command += ' ' + (await parser.getElement(imapFormalSyntax.command()));
-    }
+        response.command = await parser.getCommand();
 
-    if (parser.remainder.trim().length) {
-        await parser.getSpace();
-        response.attributes = await parser.getAttributes();
-    }
+        if (nullBytesRemoved) {
+            response.nullBytesRemoved = nullBytesRemoved;
+        }
 
-    if (parser.humanReadable) {
-        response.attributes = (response.attributes || []).concat({
-            type: 'TEXT',
-            value: parser.humanReadable
-        });
+        if (['UID', 'AUTHENTICATE'].indexOf((response.command || '').toUpperCase()) >= 0) {
+            await parser.getSpace();
+            response.command += ' ' + (await parser.getElement(imapFormalSyntax.command()));
+        }
+
+        if (parser.remainder.trim().length) {
+            await parser.getSpace();
+            response.attributes = await parser.getAttributes();
+        }
+
+        if (parser.humanReadable) {
+            response.attributes = (response.attributes || []).concat({
+                type: 'TEXT',
+                value: parser.humanReadable
+            });
+        }
+    } catch (err) {
+        if (err.code === 'ParserErrorExchange' && err.parserContext && err.parserContext.value) {
+            return err.parserContext.value;
+        }
+        throw err;
     }
 
     return response;

package/lib/handler/parser-instance.js

@@ -73,16 +73,42 @@ class ParserInstance {
         let match, element, errPos;
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
+            let error = new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
+            error.code = 'ParserError1';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if ((match = this.remainder.match(/^\s*[^\s]+(?=\s|$)/))) {
             element = match[0];
             if ((errPos = imapFormalSyntax.verify(element, syntax)) >= 0) {
-                throw new Error(`Unexpected char at position ${this.pos + errPos} [E2: ${JSON.stringify(element.charAt(errPos))}]`);
+                if (this.tag === 'Server' && element === 'Unavailable.') {
+                    // Exchange error
+                    let error = new Error(`Server returned an error: ${this.input}`);
+                    error.code = 'ParserErrorExchange';
+                    error.parserContext = {
+                        input: this.input,
+                        element,
+                        pos: this.pos,
+                        value: {
+                            tag: '*',
+                            command: 'BAD',
+                            attributes: [{ type: 'TEXT', value: this.input }]
+                        }
+                    };
+                    throw error;
+                }
+
+                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 };
+                throw error;
             }
         } else {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E3]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E3]`);
+            error.code = 'ParserError3';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         this.pos += match[0].length;
@@ -93,11 +119,17 @@ class ParserInstance {
 
     async getSpace() {
         if (!this.remainder.length) {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E4]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E4]`);
+            error.code = 'ParserError4';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if (imapFormalSyntax.verify(this.remainder.charAt(0), imapFormalSyntax.SP()) >= 0) {
-            throw new Error(`Unexpected char at position ${this.pos} [E5: ${JSON.stringify(this.remainder.charAt(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 };
+            throw error;
         }
 
         this.pos++;
@@ -106,11 +138,17 @@ class ParserInstance {
 
     async getAttributes() {
         if (!this.remainder.length) {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E6]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E6]`);
+            error.code = 'ParserError6';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error(`Unexpected whitespace at position ${this.pos} [E7]`);
+            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 };
+            throw error;
         }
 
         const tokenParser = new TokenParser(this, this.pos, this.remainder, this.options);

package/lib/handler/token-parser.js

@@ -4,6 +4,17 @@
 
 const imapFormalSyntax = require('./imap-formal-syntax');
 
+const STATE_ATOM = 0x001;
+const STATE_LITERAL = 0x002;
+const STATE_NORMAL = 0x003;
+const STATE_PARTIAL = 0x004;
+const STATE_SEQUENCE = 0x005;
+const STATE_STRING = 0x006;
+const STATE_TEXT = 0x007;
+
+const RE_DIGITS = /^\d+$/;
+const RE_SINGLE_DIGIT = /^\d$/;
+
 class TokenParser {
     constructor(parent, startPos, str, options) {
         this.str = (str || '').toString();
@@ -15,7 +26,7 @@ class TokenParser {
 
         this.currentNode.type = 'TREE';
 
-        this.state = 'NORMAL';
+        this.state = STATE_NORMAL;
     }
 
     async getAttributes() {
@@ -36,7 +47,10 @@ class TokenParser {
 
             // If the node was never closed, throw it
             if (!node.isClosed) {
-                throw new Error(`Unexpected end of input at position ${this.pos + this.str.length - 1} [E6]`);
+                let error = new Error(`Unexpected end of input at position ${this.pos + this.str.length - 1} [E9]`);
+                error.code = 'ParserError9';
+                error.parserContext = { input: this.str, pos: this.pos + this.str.length - 1 };
+                throw error;
             }
 
             let type = (node.type || '').toString().toUpperCase();
@@ -129,13 +143,13 @@ class TokenParser {
             chr = this.str.charAt(i);
 
             switch (this.state) {
-                case 'NORMAL':
+                case STATE_NORMAL:
                     switch (chr) {
                         // DQUOTE starts a new string
                         case '"':
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'string';
-                            this.state = 'STRING';
+                            this.state = STATE_STRING;
                             this.currentNode.isClosed = false;
                             break;
 
@@ -149,7 +163,10 @@ class TokenParser {
                         // ) closes a list
                         case ')':
                             if (this.currentNode.type !== 'LIST') {
-                                throw new Error(`Unexpected list terminator ) at position ${this.pos + i} [E7]`);
+                                let error = new Error(`Unexpected list terminator ) at position ${this.pos + i} [E10]`);
+                                error.code = 'ParserError10';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
 
                             this.currentNode.isClosed = true;
@@ -162,7 +179,10 @@ class TokenParser {
                         // ] closes section group
                         case ']':
                             if (this.currentNode.type !== 'SECTION') {
-                                throw new Error(`Unexpected section terminator ] at position ${this.pos + i} [E8]`);
+                                let error = new Error(`Unexpected section terminator ] at position ${this.pos + i} [E11]`);
+                                error.code = 'ParserError11';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
                             this.currentNode.isClosed = true;
                             this.currentNode.endPos = this.pos + i;
@@ -177,11 +197,11 @@ class TokenParser {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'ATOM';
                                 this.currentNode.value = chr;
-                                this.state = 'ATOM';
+                                this.state = STATE_ATOM;
                             } else {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'PARTIAL';
-                                this.state = 'PARTIAL';
+                                this.state = STATE_PARTIAL;
                                 this.currentNode.isClosed = false;
                             }
                             break;
@@ -195,11 +215,14 @@ class TokenParser {
                                     this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                     this.currentNode.type = 'ATOM';
                                     this.currentNode.value = chr;
-                                    this.state = 'ATOM';
+                                    this.state = STATE_ATOM;
                                     break;
                                 }
 
-                                throw new Error(`Unexpected literal8 marker at position ${this.pos + i} [E9]`);
+                                let error = new Error(`Unexpected literal8 marker at position ${this.pos + i} [E12]`);
+                                error.code = 'ParserError12';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
                             this.expectedLiteralType = 'literal8';
                             break;
@@ -211,7 +234,7 @@ class TokenParser {
                             this.currentNode.type = 'LITERAL';
                             this.currentNode.literalType = this.expectedLiteralType || 'literal';
                             this.expectedLiteralType = false;
-                            this.state = 'LITERAL';
+                            this.state = STATE_LITERAL;
                             this.currentNode.isClosed = false;
                             break;
 
@@ -221,7 +244,7 @@ class TokenParser {
                             this.currentNode.type = 'SEQUENCE';
                             this.currentNode.value = chr;
                             this.currentNode.isClosed = false;
-                            this.state = 'SEQUENCE';
+                            this.state = STATE_SEQUENCE;
                             break;
 
                         // normally a space should never occur
@@ -241,7 +264,7 @@ class TokenParser {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'SECTION';
                                 this.currentNode.isClosed = false;
-                                this.state = 'NORMAL';
+                                this.state = STATE_NORMAL;
 
                                 // RFC2221 defines a response code REFERRAL whose payload is an
                                 // RFC2192/RFC5092 imapurl that we will try to parse as an ATOM but
@@ -282,23 +305,26 @@ class TokenParser {
                             // Allow % to support LIST '' %
                             // Allow 8bit characters (presumably unicode)
                             if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== '\\' && chr !== '%' && chr.charCodeAt(0) < 0x80) {
-                                throw new Error(`Unexpected char at position ${this.pos + i} [E10: ${JSON.stringify(chr)}]`);
+                                let error = new Error(`Unexpected char at position ${this.pos + i} [E13: ${JSON.stringify(chr)}]`);
+                                error.code = 'ParserError13';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
 
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'ATOM';
                             this.currentNode.value = chr;
-                            this.state = 'ATOM';
+                            this.state = STATE_ATOM;
                             break;
                     }
                     break;
 
-                case 'ATOM':
+                case STATE_ATOM:
                     // space finishes an atom
                     if (chr === ' ') {
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     }
 
@@ -313,34 +339,40 @@ class TokenParser {
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         checkSP();
 
                         break;
                     }
 
-                    if ((chr === ',' || chr === ':') && this.currentNode.value.match(/^\d+$/)) {
+                    if ((chr === ',' || chr === ':') && RE_DIGITS.test(this.currentNode.value)) {
                         this.currentNode.type = 'SEQUENCE';
                         this.currentNode.isClosed = true;
-                        this.state = 'SEQUENCE';
+                        this.state = STATE_SEQUENCE;
                     }
 
                     // [ starts a section group for this element
                     if (chr === '[') {
                         // allowed only for selected elements
                         if (['BODY', 'BODY.PEEK', 'BINARY', 'BINARY.PEEK'].indexOf(this.currentNode.value.toUpperCase()) < 0) {
-                            throw new Error(`Unexpected section start char [ at position ${this.pos} [E11]`);
+                            let error = new Error(`Unexpected section start char [ at position ${this.pos + i} [E14]`);
+                            error.code = 'ParserError14';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.createNode(this.currentNode.parentNode, this.pos + i);
                         this.currentNode.type = 'SECTION';
                         this.currentNode.isClosed = false;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     }
 
                     if (chr === '<') {
-                        throw new Error(`Unexpected start of partial at position ${this.pos} [E12]`);
+                        let error = new Error(`Unexpected start of partial at position ${this.pos + i} [E15]`);
+                        error.code = 'ParserError15';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     // if the char is not ATOM compatible, throw. Allow \* as an exception
@@ -351,21 +383,27 @@ class TokenParser {
                         !(chr === '*' && this.currentNode.value === '\\') &&
                         (!this.parent || !this.parent.command || !['NO', 'BAD', 'OK'].includes(this.parent.command))
                     ) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E13: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E16: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError16';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     } else if (this.currentNode.value === '\\*') {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E14: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E17: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError17';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;
                     break;
 
-                case 'STRING':
+                case STATE_STRING:
                     // DQUOTE ends the string sequence
                     if (chr === '"') {
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
 
                         checkSP();
                         break;
@@ -375,7 +413,10 @@ class TokenParser {
                     if (chr === '\\') {
                         i++;
                         if (i >= len) {
-                            throw new Error(`Unexpected end of input at position ${this.pos + i} [E15]`);
+                            let error = new Error(`Unexpected end of input at position ${this.pos + i} [E18]`);
+                            error.code = 'ParserError18';
+                            error.parserContext = { input: this.str, pos: this.pos + i };
+                            throw error;
                         }
                         chr = this.str.charAt(i);
                     }
@@ -383,35 +424,47 @@ class TokenParser {
                     this.currentNode.value += chr;
                     break;
 
-                case 'PARTIAL':
+                case STATE_PARTIAL:
                     if (chr === '>') {
-                        if (this.currentNode.value.substr(-1) === '.') {
-                            throw new Error(`Unexpected end of partial at position ${this.pos} [E16]`);
+                        if (this.currentNode.value.at(-1) === '.') {
+                            let error = new Error(`Unexpected end of partial at position ${this.pos + 1} [E19]`);
+                            error.code = 'ParserError19';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         checkSP();
                         break;
                     }
 
                     if (chr === '.' && (!this.currentNode.value.length || this.currentNode.value.match(/\./))) {
-                        throw new Error(`Unexpected partial separator . at position ${this.pos} [E17]`);
+                        let error = new Error(`Unexpected partial separator . at position ${this.pos + 1} [E20]`);
+                        error.code = 'ParserError20';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0 && chr !== '.') {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E18: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E21: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError21';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     if (this.currentNode.value.match(/^0$|\.0$/) && chr !== '.') {
-                        throw new Error(`Invalid partial at position ${this.pos + i} [E19: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Invalid partial at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError22';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;
                     break;
 
-                case 'LITERAL':
+                case STATE_LITERAL:
                     if (this.currentNode.started) {
                         // only relevant if literals are not already parsed out from input
 
@@ -431,7 +484,7 @@ class TokenParser {
                             this.currentNode.value = this.currentNode.chBuffer.toString('binary');
                             this.currentNode.chBuffer = Buffer.alloc(0);
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         }
                         break;
@@ -444,14 +497,20 @@ class TokenParser {
 
                     if (chr === '}') {
                         if (!('literalLength' in this.currentNode)) {
-                            throw new Error(`Unexpected literal prefix end char } at position ${this.pos + i} [E20]`);
+                            let error = new Error(`Unexpected literal prefix end char } at position ${this.pos + i} [E23]`);
+                            error.code = 'ParserError23';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         if (this.str.charAt(i + 1) === '\n') {
                             i++;
                         } else if (this.str.charAt(i + 1) === '\r' && this.str.charAt(i + 2) === '\n') {
                             i += 2;
                         } else {
-                            throw new Error(`Unexpected char at position ${this.pos + i} [E21: ${JSON.stringify(chr)}]`);
+                            let error = new Error(`Unexpected char at position ${this.pos + i} [E24: ${JSON.stringify(chr)}]`);
+                            error.code = 'ParserError24';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
                         this.currentNode.literalLength = Number(this.currentNode.literalLength);
@@ -462,7 +521,7 @@ class TokenParser {
                             this.currentNode.endPos = this.pos + i;
                             this.currentNode.isClosed = true;
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         } else if (this.options.literals) {
                             // use the next precached literal values
@@ -480,7 +539,7 @@ class TokenParser {
                             this.currentNode.started = false;
                             this.currentNode.isClosed = true;
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         } else {
                             this.currentNode.started = true;
@@ -492,29 +551,41 @@ class TokenParser {
                         break;
                     }
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E25: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError25';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
                     if (this.currentNode.literalLength === '0') {
-                        throw new Error(`Invalid literal at position ${this.pos + i} [E23]`);
+                        let error = new Error(`Invalid literal at position ${this.pos + i} [E26]`);
+                        error.code = 'ParserError26';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
                     break;
 
-                case 'SEQUENCE':
+                case STATE_SEQUENCE:
                     // space finishes the sequence set
                     if (chr === ' ') {
-                        if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E24]`);
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
+                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E27]`);
+                            error.code = 'ParserError27';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
-                        if (this.currentNode.value !== '*' && this.currentNode.value.substr(-1) === '*' && this.currentNode.value.substr(-2, 1) !== ':') {
-                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E25]`);
+                        if (this.currentNode.value !== '*' && this.currentNode.value.at(-1) === '*' && this.currentNode.value.at(-2) !== ':') {
+                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E28]`);
+                            error.code = 'ParserError28';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     } else if (this.currentNode.parentNode && chr === ']' && this.currentNode.parentNode.type === 'SECTION') {
                         this.currentNode.endPos = this.pos + i - 1;
@@ -523,39 +594,57 @@ class TokenParser {
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
 
                         checkSP();
                         break;
                     }
 
                     if (chr === ':') {
-                        if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected range separator : at position ${this.pos + i} [E26]`);
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
+                            let error = new Error(`Unexpected range separator : at position ${this.pos + i} [E29]`);
+                            error.code = 'ParserError29';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                     } else if (chr === '*') {
-                        if ([',', ':'].indexOf(this.currentNode.value.substr(-1)) < 0) {
-                            throw new Error(`Unexpected range wildcard at position ${this.pos + i} [E27]`);
+                        if ([',', ':'].indexOf(this.currentNode.value.at(-1)) < 0) {
+                            let error = new Error(`Unexpected range wildcard at position ${this.pos + i} [E30]`);
+                            error.code = 'ParserError30';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                     } else if (chr === ',') {
-                        if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E28]`);
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
+                            let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E31]`);
+                            error.code = 'ParserError31';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
-                        if (this.currentNode.value.substr(-1) === '*' && this.currentNode.value.substr(-2, 1) !== ':') {
-                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E29]`);
+                        if (this.currentNode.value.at(-1) === '*' && this.currentNode.value.at(-2) !== ':') {
+                            let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E32]`);
+                            error.code = 'ParserError32';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
-                    } else if (!chr.match(/\d/)) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E30: ${JSON.stringify(chr)}]`);
+                    } else if (!RE_SINGLE_DIGIT.test(chr)) {
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E33: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError33';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
-                    if (chr.match(/\d/) && this.currentNode.value.substr(-1) === '*') {
-                        throw new Error(`Unexpected number at position ${this.pos + i} [E31: ${JSON.stringify(chr)}]`);
+                    if (RE_SINGLE_DIGIT.test(chr) && this.currentNode.value.at(-1) === '*') {
+                        let error = new Error(`Unexpected number at position ${this.pos + i} [E34: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError34';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;
                     break;
 
-                case 'TEXT':
+                case STATE_TEXT:
                     this.currentNode.value += chr;
                     break;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.154",
+    "version": "1.0.156",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {

package/test/imap-parser-test.js

@@ -978,6 +978,14 @@ module.exports['IMAP Parser, NO with a dot'] = test =>
         test.deepEqual(parsed.attributes, [{ type: 'TEXT', value: 'Server Unavailable. 15' }]);
     });
 
+module.exports['IMAP Parser, no tag or response (Exchange)'] = test =>
+    asyncWrapper(test, async test => {
+        let parsed = await parser('Server Unavailable. 15');
+        console.log(parsed);
+        test.equal(parsed.command, 'BAD');
+        test.deepEqual(parsed.attributes, [{ type: 'TEXT', value: 'Server Unavailable. 15' }]);
+    });
+
 module.exports['IMAP Parser, BAD with throttling'] = test =>
     asyncWrapper(test, async test => {
         let parsed = await parser('X BAD Request is throttled. Suggested Backoff Time: 92415 milliseconds');