imapflow 2.2.6 → 2.2.8

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

@@ -1,6 +1,6 @@
 /* eslint new-cap: 0 */
 import imapFormalSyntax from './imap-formal-syntax.js';
-import { MAX_LITERAL_SIZE, normalizeLimit, createLiteralTooLargeError } from './limits.js';
+import { MAX_LITERAL_SIZE, ERROR_CONTEXT_LENGTH, boundedInput, normalizeLimit, createLiteralTooLargeError } from './limits.js';
 const STATE_ATOM = 0x001;
 const STATE_LITERAL = 0x002;
 const STATE_NORMAL = 0x003;
@@ -67,7 +67,7 @@ export class TokenParser {
             if (!node.isClosed) {
                 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 };
+                error.parserContext = { ...boundedInput(this.str), pos: this.pos + this.str.length - 1 };
                 throw error;
             }
             let type = (node.type || '').toString().toUpperCase();
@@ -141,7 +141,8 @@ export class TokenParser {
         if (node.depth > MAX_NODE_DEPTH) {
             let error = new Error('Too much nesting in IMAP string');
             error.code = 'MAX_IMAP_NESTING_REACHED';
-            error._imapStr = this.str;
+            // A bounded prefix only, the error travels whole into logs and rejections
+            error._imapStr = this.str.slice(0, ERROR_CONTEXT_LENGTH);
             throw error;
         }
         if (typeof startPos === 'number') {
@@ -220,7 +221,7 @@ export class TokenParser {
             if (!literals.length) {
                 let error = new Error(`Literal without data at position ${this.pos + i} [E35]`);
                 error.code = 'ParserError35';
-                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                 throw error;
             }
             return literals.shift();
@@ -235,7 +236,7 @@ export class TokenParser {
             if (!imapFormalSyntax['ATOM-CHAR']().includes(chr) && chr !== '\\' && chr !== '%' && chr.charCodeAt(0) < 0x80) {
                 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 };
+                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                 throw error;
             }
             this.currentNode = this.createNode(this.currentNode, this.pos + i);
@@ -266,7 +267,7 @@ export class TokenParser {
                             if (this.currentNode.type !== 'LIST') {
                                 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 };
+                                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                                 throw error;
                             }
                             this.currentNode.isClosed = true;
@@ -279,7 +280,7 @@ export class TokenParser {
                             if (this.currentNode.type !== 'SECTION') {
                                 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 };
+                                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                                 throw error;
                             }
                             this.currentNode.isClosed = true;
@@ -323,7 +324,7 @@ export class TokenParser {
                                 }
                                 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 };
+                                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                                 throw error;
                             }
                             // Mark the next literal as literal8 type; consumed when '{' is encountered
@@ -483,16 +484,16 @@ export class TokenParser {
                         chr.charCodeAt(0) < 0x80 && // allow 8bit (presumably unicode) bytes
                         chr !== ']' &&
                         !(chr === '*' && this.currentNode.value === '\\') &&
-                        (!this.parent || !this.parent.command || !['NO', 'BAD', 'OK'].includes(this.parent.command))) {
+                        (!this.parent || !this.parent.command || !['NO', 'BAD', 'OK'].includes(this.parent.command.toUpperCase()))) {
                         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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     else if (this.currentNode.value === '\\*') {
                         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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     appendToToken(chr);
@@ -513,7 +514,7 @@ export class TokenParser {
                         if (i >= len) {
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i };
                             throw error;
                         }
                         chr = this.str.charAt(i);
@@ -525,7 +526,7 @@ export class TokenParser {
                         if (tokenLast === '.') {
                             let error = new Error(`Unexpected end of partial at position ${this.pos + i} [E19]`);
                             error.code = 'ParserError19';
-                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         this.currentNode.endPos = this.pos + i;
@@ -538,19 +539,19 @@ export class TokenParser {
                     if (chr === '.' && (!tokenLength || tokenHasDot)) {
                         let error = new Error(`Unexpected partial separator . at position ${this.pos + i} [E20]`);
                         error.code = 'ParserError20';
-                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     if (!imapFormalSyntax.DIGIT().includes(chr) && 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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     if (tokenLast === '0' && (tokenLength === 1 || tokenPrev === '.') && 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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     appendToToken(chr);
@@ -585,7 +586,7 @@ export class TokenParser {
                         if (!('literalLength' in this.currentNode)) {
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         if (this.str.charAt(i + 1) === '\n') {
@@ -597,7 +598,7 @@ export class TokenParser {
                         else {
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         this.currentNode.literalLength = Number(this.currentNode.literalLength);
@@ -647,7 +648,7 @@ export class TokenParser {
                             if (literalLength > this.maxLiteralSize || literalLength > available) {
                                 let overMax = literalLength > this.maxLiteralSize;
                                 let error = createLiteralTooLargeError(literalLength, overMax ? this.maxLiteralSize : available, overMax ? null : `the ${available} bytes available in the input`);
-                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                                 throw error;
                             }
                             this.currentNode.started = true;
@@ -661,13 +662,13 @@ export class TokenParser {
                     if (!imapFormalSyntax.DIGIT().includes(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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     if (this.currentNode.literalLength === '0') {
                         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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
@@ -685,13 +686,13 @@ export class TokenParser {
                             }
                             let error = new Error(`Unexpected end of sequence at position ${this.pos + i} [E27: ${JSON.stringify(chr)}]`);
                             error.code = 'ParserError27';
-                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         if (this.currentNode.value !== '*' && tokenLast === '*' && tokenPrev !== ':') {
                             let error = new Error(`Unexpected end of sequence at position ${this.pos + i} [E28: ${JSON.stringify(chr)}]`);
                             error.code = 'ParserError28';
-                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         this.currentNode.isClosed = true;
@@ -714,7 +715,7 @@ export class TokenParser {
                             }
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                     }
@@ -722,7 +723,7 @@ export class TokenParser {
                         if (![',', ':'].includes(tokenLast)) {
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                     }
@@ -734,13 +735,13 @@ export class TokenParser {
                             }
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                         if (tokenLast === '*' && tokenPrev !== ':') {
                             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 };
+                            error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                             throw error;
                         }
                     }
@@ -751,13 +752,13 @@ export class TokenParser {
                         }
                         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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     if (RE_SINGLE_DIGIT.test(chr) && tokenLast === '*') {
                         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 };
+                        error.parserContext = { ...boundedInput(this.str), pos: this.pos + i, chr };
                         throw error;
                     }
                     appendToToken(chr);
@@ -769,5 +770,12 @@ export class TokenParser {
         if (this.state === STATE_SEQUENCE && (tokenLast === ':' || tokenLast === ',') && !tokenHasStar) {
             this.currentNode.type = 'ATOM';
         }
+        // A star-led sequence set ("*:4") is only closed by a space or a closing delimiter, so one
+        // that ends the input is closed here, under the same rules a space applies to it. A bare "*"
+        // is left to getAttributes(), which reads it as an atom
+        if (this.state === STATE_SEQUENCE && !this.currentNode.isClosed && (RE_SINGLE_DIGIT.test(tokenLast) || (tokenLast === '*' && tokenPrev === ':'))) {
+            this.currentNode.isClosed = true;
+            this.currentNode.endPos = this.pos + this.str.length - 1;
+        }
     }
 }

package/dist/esm/imap-flow.d.ts

@@ -122,8 +122,8 @@ export declare class ImapFlow extends EventEmitter {
      */
     usable: boolean;
     /**
-     * Currently authenticated user or `false` if mailbox is not open
-     * or `true` if connection was authenticated by PREAUTH
+     * `true` once the connection is authenticated (by LOGIN, AUTHENTICATE or a PREAUTH greeting),
+     * `false` before that. The user name is in `options.auth.user`
      */
     authenticated: string | boolean;
     /**