@codingame/monaco-vscode-api 5.3.0 → 6.0.1

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

@@ -1,6 +1,7 @@
+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 { localizeWithPath } from '../../../nls.js';
 import { illegalArgument } from '../../../base/common/errors.js';
 const _moduleId = "vs/platform/contextkey/common/contextkey";
@@ -23,6 +24,25 @@ 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
 };
@@ -66,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;
             }
@@ -84,7 +104,7 @@ class Parser {
     }
     _or() {
         const expr = [this._and()];
-        while (this._matchOne(16 )) {
+        while (this._matchOne(TokenType.Or)) {
             const right = this._and();
             expr.push(right);
         }
@@ -92,29 +112,29 @@ class Parser {
     }
     _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)));
     }
     _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))
@@ -128,28 +148,28 @@ 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 : {
+            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;
@@ -165,35 +185,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--;
                                             }
                                         }
@@ -219,7 +239,7 @@ class Parser {
                                  (ContextKeyExpr.regex(key, regexp))
                             );
                         }
-                        case 18 : {
+                        case TokenType.QuotedStr: {
                             const serializedValue = expr.lexeme;
                             this._advance();
                             let regex = null;
@@ -246,17 +266,17 @@ 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 ) {
+                        if (this._previous().type === TokenType.QuotedStr) {
                             return (
                                  (ContextKeyExpr.equals(key, right))
                             );
@@ -274,10 +294,10 @@ class Parser {
                                 );
                         }
                     }
-                    case 4 : {
+                    case TokenType.NotEq: {
                         this._advance();
                         const right = this._value();
-                        if (this._previous().type === 18 ) {
+                        if (this._previous().type === TokenType.QuotedStr) {
                             return (
                                  (ContextKeyExpr.notEquals(key, right))
                             );
@@ -295,19 +315,19 @@ class Parser {
                                 );
                         }
                     }
-                    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:
@@ -316,7 +336,7 @@ class Parser {
                         );
                 }
             }
-            case 20 :
+            case TokenType.EOF:
                 this._parsingErrors.push({ message: errorUnexpectedEOF, offset: peek.offset, lexeme: '', additionalInfo: hintUnexpectedEOF });
                 throw Parser._parseError;
             default:
@@ -326,17 +346,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:
@@ -388,7 +408,7 @@ class Parser {
         return this._tokens[this._current];
     }
     _isAtEnd() {
-        return this._peek().type === 20 ;
+        return this._peek().type === TokenType.EOF;
     }
 }
 class ContextKeyExpr {
@@ -498,7 +518,7 @@ function cmp(a, b) {
 class ContextKeyFalseExpr {
     static { this.INSTANCE = ( (new ContextKeyFalseExpr())); }
     constructor() {
-        this.type = 0 ;
+        this.type = ContextKeyExprType.False;
     }
     cmp(other) {
         return this.type - other.type;
@@ -528,7 +548,7 @@ class ContextKeyFalseExpr {
 class ContextKeyTrueExpr {
     static { this.INSTANCE = ( (new ContextKeyTrueExpr())); }
     constructor() {
-        this.type = 1 ;
+        this.type = ContextKeyExprType.True;
     }
     cmp(other) {
         return this.type - other.type;
@@ -568,7 +588,7 @@ class ContextKeyDefinedExpr {
     constructor(key, negated) {
         this.key = key;
         this.negated = negated;
-        this.type = 2 ;
+        this.type = ContextKeyExprType.Defined;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -626,7 +646,7 @@ class ContextKeyEqualsExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 4 ;
+        this.type = ContextKeyExprType.Equals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -676,7 +696,7 @@ class ContextKeyInExpr {
     constructor(key, valueKey) {
         this.key = key;
         this.valueKey = valueKey;
-        this.type = 10 ;
+        this.type = ContextKeyExprType.In;
         this.negated = null;
     }
     cmp(other) {
@@ -730,7 +750,7 @@ class ContextKeyNotInExpr {
     constructor(key, valueKey) {
         this.key = key;
         this.valueKey = valueKey;
-        this.type = 11 ;
+        this.type = ContextKeyExprType.NotIn;
         this._negated = ContextKeyInExpr.create(key, valueKey);
     }
     cmp(other) {
@@ -791,7 +811,7 @@ class ContextKeyNotEqualsExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 5 ;
+        this.type = ContextKeyExprType.NotEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -845,7 +865,7 @@ class ContextKeyNotExpr {
     constructor(key, negated) {
         this.key = key;
         this.negated = negated;
-        this.type = 3 ;
+        this.type = ContextKeyExprType.Not;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -905,7 +925,7 @@ class ContextKeyGreaterExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 12 ;
+        this.type = ContextKeyExprType.Greater;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -952,7 +972,7 @@ class ContextKeyGreaterEqualsExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 13 ;
+        this.type = ContextKeyExprType.GreaterEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -999,7 +1019,7 @@ class ContextKeySmallerExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 14 ;
+        this.type = ContextKeyExprType.Smaller;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1046,7 +1066,7 @@ class ContextKeySmallerEqualsExpr {
         this.key = key;
         this.value = value;
         this.negated = negated;
-        this.type = 15 ;
+        this.type = ContextKeyExprType.SmallerEquals;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1094,7 +1114,7 @@ class ContextKeyRegexExpr {
     constructor(key, regexp) {
         this.key = key;
         this.regexp = regexp;
-        this.type = 7 ;
+        this.type = ContextKeyExprType.Regex;
         this.negated = null;
     }
     cmp(other) {
@@ -1159,7 +1179,7 @@ class ContextKeyNotRegexExpr {
     }
     constructor(_actual) {
         this._actual = _actual;
-        this.type = 8 ;
+        this.type = ContextKeyExprType.NotRegex;
     }
     cmp(other) {
         if (other.type !== this.type) {
@@ -1224,7 +1244,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) {
@@ -1280,14 +1300,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;
             }
@@ -1314,7 +1334,7 @@ class ContextKeyAndExpr {
         }
         while (expr.length > 1) {
             const lastElement = expr[expr.length - 1];
-            if (lastElement.type !== 9 ) {
+            if (lastElement.type !== ContextKeyExprType.Or) {
                 break;
             }
             expr.pop();
@@ -1383,7 +1403,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) {
@@ -1441,14 +1461,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;
                 }
@@ -1590,16 +1610,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;
@@ -1607,8 +1627,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) {
@@ -1639,9 +1659,9 @@ 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 };