@codingame/monaco-vscode-api 11.1.2 → 12.0.1

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -1,10 +1,12 @@
+
+import { CharCode } from '../../../base/common/charCode.js';
 import { isMacintosh, isLinux, isWindows, isWeb, isEdge, isFirefox, isChrome, isSafari } from '../../../base/common/platform.js';
 import { isFalsyOrWhitespace } from '../../../base/common/strings.js';
-import { Scanner } from './scanner.js';
+import { Scanner, TokenType } from './scanner.js';
 import { localize } from '../../../nls.js';
 import { illegalArgument } from '../../../base/common/errors.js';
 
-const CONSTANT_VALUES = ( (new Map()));
+const CONSTANT_VALUES = ( new Map());
 CONSTANT_VALUES.set('false', false);
 CONSTANT_VALUES.set('true', true);
 CONSTANT_VALUES.set('isMac', isMacintosh);
@@ -23,22 +25,41 @@ function setConstant(key, value) {
     CONSTANT_VALUES.set(key, value);
 }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
+var ContextKeyExprType;
+(function (ContextKeyExprType) {
+    ContextKeyExprType[ContextKeyExprType["False"] = 0] = "False";
+    ContextKeyExprType[ContextKeyExprType["True"] = 1] = "True";
+    ContextKeyExprType[ContextKeyExprType["Defined"] = 2] = "Defined";
+    ContextKeyExprType[ContextKeyExprType["Not"] = 3] = "Not";
+    ContextKeyExprType[ContextKeyExprType["Equals"] = 4] = "Equals";
+    ContextKeyExprType[ContextKeyExprType["NotEquals"] = 5] = "NotEquals";
+    ContextKeyExprType[ContextKeyExprType["And"] = 6] = "And";
+    ContextKeyExprType[ContextKeyExprType["Regex"] = 7] = "Regex";
+    ContextKeyExprType[ContextKeyExprType["NotRegex"] = 8] = "NotRegex";
+    ContextKeyExprType[ContextKeyExprType["Or"] = 9] = "Or";
+    ContextKeyExprType[ContextKeyExprType["In"] = 10] = "In";
+    ContextKeyExprType[ContextKeyExprType["NotIn"] = 11] = "NotIn";
+    ContextKeyExprType[ContextKeyExprType["Greater"] = 12] = "Greater";
+    ContextKeyExprType[ContextKeyExprType["GreaterEquals"] = 13] = "GreaterEquals";
+    ContextKeyExprType[ContextKeyExprType["Smaller"] = 14] = "Smaller";
+    ContextKeyExprType[ContextKeyExprType["SmallerEquals"] = 15] = "SmallerEquals";
+})(ContextKeyExprType || (ContextKeyExprType = {}));
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(476, "Empty context key expression"));
+const errorEmptyString = ( localize(1628, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    477,
+    1629,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(478, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(479, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(480, "Unexpected token"));
-const hintUnexpectedToken = ( localize(481, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(482, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(483, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1630, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1631, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1632, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1633, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1634, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1635, "Did you forget to put a context key?"));
 class Parser {
-    static { this._parseError = ( (new Error())); }
+    static { this._parseError = ( new Error()); }
     get lexingErrors() {
         return this._scanner.errors;
     }
@@ -47,7 +68,7 @@ class Parser {
     }
     constructor(_config = defaultConfig) {
         this._config = _config;
-        this._scanner = ( (new Scanner()));
+        this._scanner = ( new Scanner());
         this._tokens = [];
         this._current = 0;
         this._parsingErrors = [];
@@ -65,7 +86,7 @@ class Parser {
             const expr = this._expr();
             if (!this._isAtEnd()) {
                 const peek = this._peek();
-                const additionalInfo = peek.type === 17  ? hintUnexpectedToken : undefined;
+                const additionalInfo = peek.type === TokenType.Str ? hintUnexpectedToken : undefined;
                 this._parsingErrors.push({ message: errorUnexpectedToken, offset: peek.offset, lexeme: Scanner.getLexeme(peek), additionalInfo });
                 throw Parser._parseError;
             }
@@ -83,41 +104,39 @@ class Parser {
     }
     _or() {
         const expr = [this._and()];
-        while (this._matchOne(16 )) {
+        while (this._matchOne(TokenType.Or)) {
             const right = this._and();
             expr.push(right);
         }
-        return expr.length === 1 ? expr[0] : ( (ContextKeyExpr.or(...expr)));
+        return expr.length === 1 ? expr[0] : ( ContextKeyExpr.or(...expr));
     }
     _and() {
         const expr = [this._term()];
-        while (this._matchOne(15 )) {
+        while (this._matchOne(TokenType.And)) {
             const right = this._term();
             expr.push(right);
         }
-        return expr.length === 1 ? expr[0] : ( (ContextKeyExpr.and(...expr)));
+        return expr.length === 1 ? expr[0] : ( ContextKeyExpr.and(...expr));
     }
     _term() {
-        if (this._matchOne(2 )) {
+        if (this._matchOne(TokenType.Neg)) {
             const peek = this._peek();
             switch (peek.type) {
-                case 11 :
+                case TokenType.True:
                     this._advance();
                     return ContextKeyFalseExpr.INSTANCE;
-                case 12 :
+                case TokenType.False:
                     this._advance();
                     return ContextKeyTrueExpr.INSTANCE;
-                case 0 : {
+                case TokenType.LParen: {
                     this._advance();
                     const expr = this._expr();
-                    this._consume(1 , errorClosingParenthesis);
+                    this._consume(TokenType.RParen, errorClosingParenthesis);
                     return expr?.negate();
                 }
-                case 17 :
+                case TokenType.Str:
                     this._advance();
-                    return (
-                         (ContextKeyNotExpr.create(peek.lexeme))
-                    );
+                    return ( ContextKeyNotExpr.create(peek.lexeme));
                 default:
                     throw this._errExpectedButGot(`KEY | true | false | '(' expression ')'`, peek);
             }
@@ -127,28 +146,26 @@ class Parser {
     _primary() {
         const peek = this._peek();
         switch (peek.type) {
-            case 11 :
+            case TokenType.True:
                 this._advance();
                 return ContextKeyExpr.true();
-            case 12 :
+            case TokenType.False:
                 this._advance();
-                return (
-                     (ContextKeyExpr.false())
-                );
-            case 0 : {
+                return ( ContextKeyExpr.false());
+            case TokenType.LParen: {
                 this._advance();
                 const expr = this._expr();
-                this._consume(1 , errorClosingParenthesis);
+                this._consume(TokenType.RParen, errorClosingParenthesis);
                 return expr;
             }
-            case 17 : {
+            case TokenType.Str: {
                 const key = peek.lexeme;
                 this._advance();
-                if (this._matchOne(9 )) {
+                if (this._matchOne(TokenType.RegexOp)) {
                     const expr = this._peek();
                     if (!this._config.regexParsingWithErrorRecovery) {
                         this._advance();
-                        if (expr.type !== 10 ) {
+                        if (expr.type !== TokenType.RegexStr) {
                             throw this._errExpectedButGot(`REGEX`, expr);
                         }
                         const regexLexeme = expr.lexeme;
@@ -156,7 +173,7 @@ class Parser {
                         const flags = closingSlashIndex === regexLexeme.length - 1 ? undefined : this._removeFlagsGY(regexLexeme.substring(closingSlashIndex + 1));
                         let regexp;
                         try {
-                            regexp = ( (new RegExp(regexLexeme.substring(1, closingSlashIndex), flags)));
+                            regexp = ( new RegExp(regexLexeme.substring(1, closingSlashIndex), flags));
                         }
                         catch (e) {
                             throw this._errExpectedButGot(`REGEX`, expr);
@@ -164,35 +181,35 @@ class Parser {
                         return ContextKeyRegexExpr.create(key, regexp);
                     }
                     switch (expr.type) {
-                        case 10 :
-                        case 19 : {
+                        case TokenType.RegexStr:
+                        case TokenType.Error: {
                             const lexemeReconstruction = [expr.lexeme];
                             this._advance();
                             let followingToken = this._peek();
                             let parenBalance = 0;
                             for (let i = 0; i < expr.lexeme.length; i++) {
-                                if (expr.lexeme.charCodeAt(i) === 40 ) {
+                                if (expr.lexeme.charCodeAt(i) === CharCode.OpenParen) {
                                     parenBalance++;
                                 }
-                                else if (expr.lexeme.charCodeAt(i) === 41 ) {
+                                else if (expr.lexeme.charCodeAt(i) === CharCode.CloseParen) {
                                     parenBalance--;
                                 }
                             }
-                            while (!this._isAtEnd() && followingToken.type !== 15  && followingToken.type !== 16 ) {
+                            while (!this._isAtEnd() && followingToken.type !== TokenType.And && followingToken.type !== TokenType.Or) {
                                 switch (followingToken.type) {
-                                    case 0 :
+                                    case TokenType.LParen:
                                         parenBalance++;
                                         break;
-                                    case 1 :
+                                    case TokenType.RParen:
                                         parenBalance--;
                                         break;
-                                    case 10 :
-                                    case 18 :
+                                    case TokenType.RegexStr:
+                                    case TokenType.QuotedStr:
                                         for (let i = 0; i < followingToken.lexeme.length; i++) {
-                                            if (followingToken.lexeme.charCodeAt(i) === 40 ) {
+                                            if (followingToken.lexeme.charCodeAt(i) === CharCode.OpenParen) {
                                                 parenBalance++;
                                             }
-                                            else if (expr.lexeme.charCodeAt(i) === 41 ) {
+                                            else if (expr.lexeme.charCodeAt(i) === CharCode.CloseParen) {
                                                 parenBalance--;
                                             }
                                         }
@@ -209,16 +226,14 @@ class Parser {
                             const flags = closingSlashIndex === regexLexeme.length - 1 ? undefined : this._removeFlagsGY(regexLexeme.substring(closingSlashIndex + 1));
                             let regexp;
                             try {
-                                regexp = ( (new RegExp(regexLexeme.substring(1, closingSlashIndex), flags)));
+                                regexp = ( new RegExp(regexLexeme.substring(1, closingSlashIndex), flags));
                             }
                             catch (e) {
                                 throw this._errExpectedButGot(`REGEX`, expr);
                             }
-                            return (
-                                 (ContextKeyExpr.regex(key, regexp))
-                            );
+                            return ( ContextKeyExpr.regex(key, regexp));
                         }
-                        case 18 : {
+                        case TokenType.QuotedStr: {
                             const serializedValue = expr.lexeme;
                             this._advance();
                             let regex = null;
@@ -229,7 +244,7 @@ class Parser {
                                     const value = serializedValue.slice(start + 1, end);
                                     const caseIgnoreFlag = serializedValue[end + 1] === 'i' ? 'i' : '';
                                     try {
-                                        regex = ( (new RegExp(value, caseIgnoreFlag)));
+                                        regex = ( new RegExp(value, caseIgnoreFlag));
                                     }
                                     catch (_e) {
                                         throw this._errExpectedButGot(`REGEX`, expr);
@@ -245,77 +260,63 @@ class Parser {
                             throw this._errExpectedButGot('REGEX', this._peek());
                     }
                 }
-                if (this._matchOne(14 )) {
-                    this._consume(13 , errorNoInAfterNot);
+                if (this._matchOne(TokenType.Not)) {
+                    this._consume(TokenType.In, errorNoInAfterNot);
                     const right = this._value();
                     return ContextKeyExpr.notIn(key, right);
                 }
                 const maybeOp = this._peek().type;
                 switch (maybeOp) {
-                    case 3 : {
+                    case TokenType.Eq: {
                         this._advance();
                         const right = this._value();
-                        if (this._previous().type === 18 ) {
-                            return (
-                                 (ContextKeyExpr.equals(key, right))
-                            );
+                        if (this._previous().type === TokenType.QuotedStr) {
+                            return ( ContextKeyExpr.equals(key, right));
                         }
                         switch (right) {
                             case 'true':
-                                return (
-                                     (ContextKeyExpr.has(key))
-                                );
+                                return ( ContextKeyExpr.has(key));
                             case 'false':
                                 return ContextKeyExpr.not(key);
                             default:
-                                return (
-                                     (ContextKeyExpr.equals(key, right))
-                                );
+                                return ( ContextKeyExpr.equals(key, right));
                         }
                     }
-                    case 4 : {
+                    case TokenType.NotEq: {
                         this._advance();
                         const right = this._value();
-                        if (this._previous().type === 18 ) {
-                            return (
-                                 (ContextKeyExpr.notEquals(key, right))
-                            );
+                        if (this._previous().type === TokenType.QuotedStr) {
+                            return ( ContextKeyExpr.notEquals(key, right));
                         }
                         switch (right) {
                             case 'true':
                                 return ContextKeyExpr.not(key);
                             case 'false':
-                                return (
-                                     (ContextKeyExpr.has(key))
-                                );
+                                return ( ContextKeyExpr.has(key));
                             default:
-                                return (
-                                     (ContextKeyExpr.notEquals(key, right))
-                                );
+                                return ( ContextKeyExpr.notEquals(key, right));
                         }
                     }
-                    case 5 :
+                    case TokenType.Lt:
                         this._advance();
                         return ContextKeySmallerExpr.create(key, this._value());
-                    case 6 :
+                    case TokenType.LtEq:
                         this._advance();
                         return ContextKeySmallerEqualsExpr.create(key, this._value());
-                    case 7 :
+                    case TokenType.Gt:
                         this._advance();
                         return ContextKeyGreaterExpr.create(key, this._value());
-                    case 8 :
+                    case TokenType.GtEq:
                         this._advance();
                         return ContextKeyGreaterEqualsExpr.create(key, this._value());
-                    case 13 :
+                    case TokenType.In:
                         this._advance();
                         return ContextKeyExpr.in(key, this._value());
                     default:
-                        return (
-                             (ContextKeyExpr.has(key))
-                        );
+                        return ( ContextKeyExpr.has(key));
                 }
             }
-            case 20 :
+            case TokenType.EOF:
                 this._parsingErrors.push({ message: errorUnexpectedEOF, offset: peek.offset, lexeme: '', additionalInfo: hintUnexpectedEOF });
                 throw Parser._parseError;
             default:
@@ -325,17 +326,17 @@ class Parser {
     _value() {
         const token = this._peek();
         switch (token.type) {
-            case 17 :
-            case 18 :
+            case TokenType.Str:
+            case TokenType.QuotedStr:
                 this._advance();
                 return token.lexeme;
-            case 11 :
+            case TokenType.True:
                 this._advance();
                 return 'true';
-            case 12 :
+            case TokenType.False:
                 this._advance();
                 return 'false';
-            case 13 :
+            case TokenType.In:
                 this._advance();
                 return 'in';
             default:
@@ -368,7 +369,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(484, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1636, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -381,7 +382,7 @@ class Parser {
         return this._tokens[this._current];
     }
     _isAtEnd() {
-        return this._peek().type === 20 ;
+        return this._peek().type === TokenType.EOF;
     }
 }
 class ContextKeyExpr {
@@ -392,9 +393,7 @@ class ContextKeyExpr {
         return ContextKeyTrueExpr.INSTANCE;
     }
     static has(key) {
-        return (
-             (ContextKeyDefinedExpr.create(key))
-        );
+        return ( ContextKeyDefinedExpr.create(key));
     }
     static equals(key, value) {
         return ContextKeyEqualsExpr.create(key, value);
@@ -412,9 +411,7 @@ class ContextKeyExpr {
         return ContextKeyNotInExpr.create(key, value);
     }
     static not(key) {
-        return (
-             (ContextKeyNotExpr.create(key))
-        );
+        return ( ContextKeyNotExpr.create(key));
     }
     static and(...expr) {
         return ContextKeyAndExpr.create(expr, null, true);
@@ -434,7 +431,7 @@ class ContextKeyExpr {
     static smallerEquals(key, value) {
         return ContextKeySmallerEqualsExpr.create(key, value);
     }
-    static { this._parser = ( (new Parser({ regexParsingWithErrorRecovery: false }))); }
+    static { this._parser = ( new Parser({ regexParsingWithErrorRecovery: false })); }
     static deserialize(serialized) {
         if (serialized === undefined || serialized === null) {
             return undefined;
@@ -444,35 +441,29 @@ class ContextKeyExpr {
     }
 }
 function validateWhenClauses(whenClauses) {
-    const parser = ( (new Parser({ regexParsingWithErrorRecovery: false })));
-    return (
-         (whenClauses.map(whenClause => {
-            parser.parse(whenClause);
-            if (parser.lexingErrors.length > 0) {
-                return (
-                     (parser.lexingErrors.map((se) => ({
-                        errorMessage: se.additionalInfo ?
-                            ( localize(485, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                            ( localize(486, "Unexpected token.")),
-                        offset: se.offset,
-                        length: se.lexeme.length,
-                    })))
-                );
-            }
-            else if (parser.parsingErrors.length > 0) {
-                return (
-                     (parser.parsingErrors.map((pe) => ({
-                        errorMessage: pe.additionalInfo ? `${pe.message}. ${pe.additionalInfo}` : pe.message,
-                        offset: pe.offset,
-                        length: pe.lexeme.length,
-                    })))
-                );
-            }
-            else {
-                return [];
-            }
-        }))
-    );
+    const parser = ( new Parser({ regexParsingWithErrorRecovery: false }));
+    return (whenClauses.map(whenClause => {
+        parser.parse(whenClause);
+        if (parser.lexingErrors.length > 0) {
+            return (parser.lexingErrors.map((se) => ({
+                errorMessage: se.additionalInfo ?
+                    ( localize(1637, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                    ( localize(1638, "Unexpected token.")),
+                offset: se.offset,
+                length: se.lexeme.length,
+            })));
+        }
+        else if (parser.parsingErrors.length > 0) {
+            return ( parser.parsingErrors.map((pe) => ({
+                errorMessage: pe.additionalInfo ? `${pe.message}. ${pe.additionalInfo}` : pe.message,
+                offset: pe.offset,
+                length: pe.lexeme.length,
+            })));
+        }
+        else {
+            return [];
+        }
+    }));
 }
 function expressionsAreEqualWithConstantSubstitution(a, b) {
     const aExpr = a ? a.substituteConstants() : undefined;
@@ -489,9 +480,9 @@ function cmp(a, b) {
     return a.cmp(b);
 }
 class ContextKeyFalseExpr {
-    static { this.INSTANCE = ( (new ContextKeyFalseExpr())); }
+    static { this.INSTANCE = ( new ContextKeyFalseExpr()); }
     constructor() {
-        this.type = 0 ;
+        this.type = ContextKeyExprType.False;
     }
     cmp(other) {
         return this.type - other.type;
@@ -519,9 +510,9 @@ class ContextKeyFalseExpr {
     }
 }
 class ContextKeyTrueExpr {
-    static { this.INSTANCE = ( (new ContextKeyTrueExpr())); }
+    static { this.INSTANCE = ( new ContextKeyTrueExpr()); }
     constructor() {
-        this.type = 1 ;
+        this.type = ContextKeyExprType.True;
     }
     cmp(other) {
         return this.type - other.type;
@@ -554,14 +545,12 @@ class ContextKeyDefinedExpr {
         if (typeof constantValue === 'boolean') {
             return constantValue ? ContextKeyTrueExpr.INSTANCE : ContextKeyFalseExpr.INSTANCE;
         }
-        return (
-             (new ContextKeyDefinedExpr(key, negated))
-        );
+        return ( new ContextKeyDefinedExpr(key, negated));
     }
     constructor(key, negated) {
         this.key = key;
         this.negated = negated;
-        this.type = 2 ;
+        this.type = ContextKeyExprType.Defined;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -596,7 +585,7 @@ class ContextKeyDefinedExpr {
     }
     negate() {
         if (!this.negated) {
-            this.negated = ( (ContextKeyNotExpr.create(this.key, this)));
+            this.negated = ( ContextKeyNotExpr.create(this.key, this));
         }
         return this.negated;
     }
@@ -604,22 +593,20 @@ class ContextKeyDefinedExpr {
 class ContextKeyEqualsExpr {
     static create(key, value, negated = null) {
         if (typeof value === 'boolean') {
-            return (value ?  (ContextKeyDefinedExpr.create(key, negated)) :  (ContextKeyNotExpr.create(key, negated)));
+            return (value ? ( ContextKeyDefinedExpr.create(key, negated)) : ( ContextKeyNotExpr.create(key, negated)));
         }
         const constantValue = CONSTANT_VALUES.get(key);
         if (typeof constantValue === 'boolean') {
             const trueValue = constantValue ? 'true' : 'false';
             return (value === trueValue ? ContextKeyTrueExpr.INSTANCE : ContextKeyFalseExpr.INSTANCE);
         }
-        return (
-             (new ContextKeyEqualsExpr(key, value, negated))
-        );
+        return ( new ContextKeyEqualsExpr(key, value, negated));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 4 ;
+        this.type = ContextKeyExprType.Equals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -662,14 +649,12 @@ class ContextKeyEqualsExpr {
 }
 class ContextKeyInExpr {
     static create(key, valueKey) {
-        return (
-             (new ContextKeyInExpr(key, valueKey))
-        );
+        return ( new ContextKeyInExpr(key, valueKey));
     }
     constructor(key, valueKey) {
         this.key = key;
         this.valueKey = valueKey;
-        this.type = 10 ;
+        this.type = ContextKeyExprType.In;
         this.negated = null;
     }
     cmp(other) {
@@ -716,14 +701,12 @@ class ContextKeyInExpr {
 }
 class ContextKeyNotInExpr {
     static create(key, valueKey) {
-        return (
-             (new ContextKeyNotInExpr(key, valueKey))
-        );
+        return ( new ContextKeyNotInExpr(key, valueKey));
     }
     constructor(key, valueKey) {
         this.key = key;
         this.valueKey = valueKey;
-        this.type = 11 ;
+        this.type = ContextKeyExprType.NotIn;
         this._negated = ContextKeyInExpr.create(key, valueKey);
     }
     cmp(other) {
@@ -748,9 +731,7 @@ class ContextKeyNotInExpr {
         return `${this.key} not in '${this.valueKey}'`;
     }
     keys() {
-        return (
-             (this._negated.keys())
-        );
+        return ( this._negated.keys());
     }
     map(mapFnc) {
         return mapFnc.mapNotIn(this.key, this.valueKey);
@@ -763,28 +744,22 @@ class ContextKeyNotEqualsExpr {
     static create(key, value, negated = null) {
         if (typeof value === 'boolean') {
             if (value) {
-                return (
-                     (ContextKeyNotExpr.create(key, negated))
-                );
+                return ( ContextKeyNotExpr.create(key, negated));
             }
-            return (
-                 (ContextKeyDefinedExpr.create(key, negated))
-            );
+            return ( ContextKeyDefinedExpr.create(key, negated));
         }
         const constantValue = CONSTANT_VALUES.get(key);
         if (typeof constantValue === 'boolean') {
             const falseValue = constantValue ? 'true' : 'false';
             return (value === falseValue ? ContextKeyFalseExpr.INSTANCE : ContextKeyTrueExpr.INSTANCE);
         }
-        return (
-             (new ContextKeyNotEqualsExpr(key, value, negated))
-        );
+        return ( new ContextKeyNotEqualsExpr(key, value, negated));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 5 ;
+        this.type = ContextKeyExprType.NotEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -831,14 +806,12 @@ class ContextKeyNotExpr {
         if (typeof constantValue === 'boolean') {
             return (constantValue ? ContextKeyFalseExpr.INSTANCE : ContextKeyTrueExpr.INSTANCE);
         }
-        return (
-             (new ContextKeyNotExpr(key, negated))
-        );
+        return ( new ContextKeyNotExpr(key, negated));
     }
     constructor(key, negated) {
         this.key = key;
         this.negated = negated;
-        this.type = 3 ;
+        this.type = ContextKeyExprType.Not;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -873,7 +846,7 @@ class ContextKeyNotExpr {
     }
     negate() {
         if (!this.negated) {
-            this.negated = ( (ContextKeyDefinedExpr.create(this.key, this)));
+            this.negated = ( ContextKeyDefinedExpr.create(this.key, this));
         }
         return this.negated;
     }
@@ -892,13 +865,13 @@ function withFloatOrStr(value, callback) {
 }
 class ContextKeyGreaterExpr {
     static create(key, _value, negated = null) {
-        return withFloatOrStr(_value, (value) => ( (new ContextKeyGreaterExpr(key, value, negated))));
+        return withFloatOrStr(_value, (value) => ( new ContextKeyGreaterExpr(key, value, negated)));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 12 ;
+        this.type = ContextKeyExprType.Greater;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -939,13 +912,13 @@ class ContextKeyGreaterExpr {
 }
 class ContextKeyGreaterEqualsExpr {
     static create(key, _value, negated = null) {
-        return withFloatOrStr(_value, (value) => ( (new ContextKeyGreaterEqualsExpr(key, value, negated))));
+        return withFloatOrStr(_value, (value) => ( new ContextKeyGreaterEqualsExpr(key, value, negated)));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 13 ;
+        this.type = ContextKeyExprType.GreaterEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -986,13 +959,13 @@ class ContextKeyGreaterEqualsExpr {
 }
 class ContextKeySmallerExpr {
     static create(key, _value, negated = null) {
-        return withFloatOrStr(_value, (value) => ( (new ContextKeySmallerExpr(key, value, negated))));
+        return withFloatOrStr(_value, (value) => ( new ContextKeySmallerExpr(key, value, negated)));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 14 ;
+        this.type = ContextKeyExprType.Smaller;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1033,13 +1006,13 @@ class ContextKeySmallerExpr {
 }
 class ContextKeySmallerEqualsExpr {
     static create(key, _value, negated = null) {
-        return withFloatOrStr(_value, (value) => ( (new ContextKeySmallerEqualsExpr(key, value, negated))));
+        return withFloatOrStr(_value, (value) => ( new ContextKeySmallerEqualsExpr(key, value, negated)));
     }
     constructor(key, value, negated) {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 15 ;
+        this.type = ContextKeyExprType.SmallerEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1080,14 +1053,12 @@ class ContextKeySmallerEqualsExpr {
 }
 class ContextKeyRegexExpr {
     static create(key, regexp) {
-        return (
-             (new ContextKeyRegexExpr(key, regexp))
-        );
+        return ( new ContextKeyRegexExpr(key, regexp));
     }
     constructor(key, regexp) {
         this.key = key;
         this.regexp = regexp;
-        this.type = 7 ;
+        this.type = ContextKeyExprType.Regex;
         this.negated = null;
     }
     cmp(other) {
@@ -1146,13 +1117,11 @@ class ContextKeyRegexExpr {
 }
 class ContextKeyNotRegexExpr {
     static create(actual) {
-        return (
-             (new ContextKeyNotRegexExpr(actual))
-        );
+        return ( new ContextKeyNotRegexExpr(actual));
     }
     constructor(_actual) {
         this._actual = _actual;
-        this.type = 8 ;
+        this.type = ContextKeyExprType.NotRegex;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1176,14 +1145,10 @@ class ContextKeyNotRegexExpr {
         return `!(${this._actual.serialize()})`;
     }
     keys() {
-        return (
-             (this._actual.keys())
-        );
+        return ( this._actual.keys());
     }
     map(mapFnc) {
-        return (
-             (new ContextKeyNotRegexExpr( (this._actual.map(mapFnc))))
-        );
+        return ( new ContextKeyNotRegexExpr(( this._actual.map(mapFnc))));
     }
     negate() {
         return this._actual;
@@ -1217,7 +1182,7 @@ class ContextKeyAndExpr {
     constructor(expr, negated) {
         this.expr = expr;
         this.negated = negated;
-        this.type = 6 ;
+        this.type = ContextKeyExprType.And;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1273,14 +1238,14 @@ class ContextKeyAndExpr {
             if (!e) {
                 continue;
             }
-            if (e.type === 1 ) {
+            if (e.type === ContextKeyExprType.True) {
                 hasTrue = true;
                 continue;
             }
-            if (e.type === 0 ) {
+            if (e.type === ContextKeyExprType.False) {
                 return ContextKeyFalseExpr.INSTANCE;
             }
-            if (e.type === 6 ) {
+            if (e.type === ContextKeyExprType.And) {
                 expr.push(...e.expr);
                 continue;
             }
@@ -1307,15 +1272,15 @@ class ContextKeyAndExpr {
         }
         while (expr.length > 1) {
             const lastElement = expr[expr.length - 1];
-            if (lastElement.type !== 9 ) {
+            if (lastElement.type !== ContextKeyExprType.Or) {
                 break;
             }
             expr.pop();
             const secondToLastElement = expr.pop();
             const isFinished = (expr.length === 0);
-            const resultElement = ContextKeyOrExpr.create(( (lastElement.expr.map(
+            const resultElement = ContextKeyOrExpr.create(( lastElement.expr.map(
                 el => ContextKeyAndExpr.create([el, secondToLastElement], null, extraRedundantCheck)
-            ))), null, isFinished);
+            )), null, isFinished);
             if (resultElement) {
                 expr.push(resultElement);
                 expr.sort(cmp);
@@ -1327,7 +1292,7 @@ class ContextKeyAndExpr {
         if (extraRedundantCheck) {
             for (let i = 0; i < expr.length; i++) {
                 for (let j = i + 1; j < expr.length; j++) {
-                    if (( (expr[i].negate())).equals(expr[j])) {
+                    if (( expr[i].negate()).equals(expr[j])) {
                         return ContextKeyFalseExpr.INSTANCE;
                     }
                 }
@@ -1336,33 +1301,26 @@ class ContextKeyAndExpr {
                 return expr[0];
             }
         }
-        return (
-             (new ContextKeyAndExpr(expr, negated))
-        );
+        return ( new ContextKeyAndExpr(expr, negated));
     }
     serialize() {
-        return ( (this.expr.map(e => e.serialize()))).join(' && ');
+        return ( this.expr.map(e => e.serialize())).join(' && ');
     }
     keys() {
         const result = [];
         for (const expr of this.expr) {
-            result.push(...( (expr.keys())));
+            result.push(...( expr.keys()));
         }
         return result;
     }
     map(mapFnc) {
-        return (
-             (new ContextKeyAndExpr(
-                 (this.expr.map(expr => ( (expr.map(mapFnc))))),
-                null
-            ))
-        );
+        return ( new ContextKeyAndExpr(( this.expr.map(expr => ( expr.map(mapFnc)))), null));
     }
     negate() {
         if (!this.negated) {
             const result = [];
             for (const expr of this.expr) {
-                result.push(( (expr.negate())));
+                result.push(( expr.negate()));
             }
             this.negated = ContextKeyOrExpr.create(result, this, true);
         }
@@ -1376,7 +1334,7 @@ class ContextKeyOrExpr {
     constructor(expr, negated) {
         this.expr = expr;
         this.negated = negated;
-        this.type = 9 ;
+        this.type = ContextKeyExprType.Or;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1434,14 +1392,14 @@ class ContextKeyOrExpr {
                 if (!e) {
                     continue;
                 }
-                if (e.type === 0 ) {
+                if (e.type === ContextKeyExprType.False) {
                     hasFalse = true;
                     continue;
                 }
-                if (e.type === 1 ) {
+                if (e.type === ContextKeyExprType.True) {
                     return ContextKeyTrueExpr.INSTANCE;
                 }
-                if (e.type === 9 ) {
+                if (e.type === ContextKeyExprType.Or) {
                     expr = expr.concat(e.expr);
                     continue;
                 }
@@ -1470,7 +1428,7 @@ class ContextKeyOrExpr {
         if (extraRedundantCheck) {
             for (let i = 0; i < expr.length; i++) {
                 for (let j = i + 1; j < expr.length; j++) {
-                    if (( (expr[i].negate())).equals(expr[j])) {
+                    if (( expr[i].negate()).equals(expr[j])) {
                         return ContextKeyTrueExpr.INSTANCE;
                     }
                 }
@@ -1479,33 +1437,26 @@ class ContextKeyOrExpr {
                 return expr[0];
             }
         }
-        return (
-             (new ContextKeyOrExpr(expr, negated))
-        );
+        return ( new ContextKeyOrExpr(expr, negated));
     }
     serialize() {
-        return ( (this.expr.map(e => e.serialize()))).join(' || ');
+        return ( this.expr.map(e => e.serialize())).join(' || ');
     }
     keys() {
         const result = [];
         for (const expr of this.expr) {
-            result.push(...( (expr.keys())));
+            result.push(...( expr.keys()));
         }
         return result;
     }
     map(mapFnc) {
-        return (
-             (new ContextKeyOrExpr(
-                 (this.expr.map(expr => ( (expr.map(mapFnc))))),
-                null
-            ))
-        );
+        return ( new ContextKeyOrExpr(( this.expr.map(expr => ( expr.map(mapFnc)))), null));
     }
     negate() {
         if (!this.negated) {
             const result = [];
             for (const expr of this.expr) {
-                result.push(( (expr.negate())));
+                result.push(( expr.negate()));
             }
             while (result.length > 1) {
                 const LEFT = result.shift();
@@ -1526,9 +1477,7 @@ class ContextKeyOrExpr {
 class RawContextKey extends ContextKeyDefinedExpr {
     static { this._info = []; }
     static all() {
-        return (
-             (RawContextKey._info.values())
-        );
+        return ( RawContextKey._info.values());
     }
     constructor(key, defaultValue, metaOrHide) {
         super(key, null);
@@ -1547,9 +1496,7 @@ class RawContextKey extends ContextKeyDefinedExpr {
         return target.getContextKeyValue(this.key);
     }
     toNegated() {
-        return (
-             (this.negate())
-        );
+        return ( this.negate());
     }
     isEqualTo(value) {
         return ContextKeyEqualsExpr.create(this.key, value);
@@ -1583,16 +1530,16 @@ function cmp2(key1, value1, key2, value2) {
     return 0;
 }
 function implies(p, q) {
-    if (p.type === 0  || q.type === 1 ) {
+    if (p.type === ContextKeyExprType.False || q.type === ContextKeyExprType.True) {
         return true;
     }
-    if (p.type === 9 ) {
-        if (q.type === 9 ) {
+    if (p.type === ContextKeyExprType.Or) {
+        if (q.type === ContextKeyExprType.Or) {
             return allElementsIncluded(p.expr, q.expr);
         }
         return false;
     }
-    if (q.type === 9 ) {
+    if (q.type === ContextKeyExprType.Or) {
         for (const element of q.expr) {
             if (implies(p, element)) {
                 return true;
@@ -1600,8 +1547,8 @@ function implies(p, q) {
         }
         return false;
     }
-    if (p.type === 6 ) {
-        if (q.type === 6 ) {
+    if (p.type === ContextKeyExprType.And) {
+        if (q.type === ContextKeyExprType.And) {
             return allElementsIncluded(q.expr, p.expr);
         }
         for (const element of p.expr) {
@@ -1632,10 +1579,10 @@ function allElementsIncluded(p, q) {
     return (pIndex === p.length);
 }
 function getTerminals(node) {
-    if (node.type === 9 ) {
+    if (node.type === ContextKeyExprType.Or) {
         return node.expr;
     }
     return [node];
 }
 
-export { ContextKeyAndExpr, ContextKeyDefinedExpr, ContextKeyEqualsExpr, ContextKeyExpr, ContextKeyFalseExpr, ContextKeyGreaterEqualsExpr, ContextKeyGreaterExpr, ContextKeyInExpr, ContextKeyNotEqualsExpr, ContextKeyNotExpr, ContextKeyNotInExpr, ContextKeyNotRegexExpr, ContextKeyOrExpr, ContextKeyRegexExpr, ContextKeySmallerEqualsExpr, ContextKeySmallerExpr, ContextKeyTrueExpr, Parser, RawContextKey, expressionsAreEqualWithConstantSubstitution, implies, setConstant, validateWhenClauses };
+export { ContextKeyAndExpr, ContextKeyDefinedExpr, ContextKeyEqualsExpr, ContextKeyExpr, ContextKeyExprType, ContextKeyFalseExpr, ContextKeyGreaterEqualsExpr, ContextKeyGreaterExpr, ContextKeyInExpr, ContextKeyNotEqualsExpr, ContextKeyNotExpr, ContextKeyNotInExpr, ContextKeyNotRegexExpr, ContextKeyOrExpr, ContextKeyRegexExpr, ContextKeySmallerEqualsExpr, ContextKeySmallerExpr, ContextKeyTrueExpr, Parser, RawContextKey, expressionsAreEqualWithConstantSubstitution, implies, setConstant, validateWhenClauses };