xmlui 0.12.19 → 0.12.21

package/dist/metadata/{transform-D0SWbm8g.js → transform-fGDqiHwH.js}

@@ -603,23 +603,23 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2[TokenType2["SignedShiftRight"] = 55] = "SignedShiftRight";
   TokenType2[TokenType2["Dot"] = 56] = "Dot";
   TokenType2[TokenType2["Spread"] = 57] = "Spread";
-  TokenType2[TokenType2["Global"] = 58] = "Global";
-  TokenType2[TokenType2["Backtick"] = 59] = "Backtick";
-  TokenType2[TokenType2["DollarLBrace"] = 60] = "DollarLBrace";
-  TokenType2[TokenType2["Arrow"] = 61] = "Arrow";
-  TokenType2[TokenType2["DecimalLiteral"] = 62] = "DecimalLiteral";
-  TokenType2[TokenType2["HexadecimalLiteral"] = 63] = "HexadecimalLiteral";
-  TokenType2[TokenType2["BinaryLiteral"] = 64] = "BinaryLiteral";
-  TokenType2[TokenType2["RealLiteral"] = 65] = "RealLiteral";
-  TokenType2[TokenType2["StringLiteral"] = 66] = "StringLiteral";
-  TokenType2[TokenType2["Infinity"] = 67] = "Infinity";
-  TokenType2[TokenType2["NaN"] = 68] = "NaN";
-  TokenType2[TokenType2["True"] = 69] = "True";
-  TokenType2[TokenType2["False"] = 70] = "False";
-  TokenType2[TokenType2["Typeof"] = 71] = "Typeof";
-  TokenType2[TokenType2["Null"] = 72] = "Null";
-  TokenType2[TokenType2["Undefined"] = 73] = "Undefined";
-  TokenType2[TokenType2["In"] = 74] = "In";
+  TokenType2[TokenType2["Backtick"] = 58] = "Backtick";
+  TokenType2[TokenType2["DollarLBrace"] = 59] = "DollarLBrace";
+  TokenType2[TokenType2["Arrow"] = 60] = "Arrow";
+  TokenType2[TokenType2["DecimalLiteral"] = 61] = "DecimalLiteral";
+  TokenType2[TokenType2["HexadecimalLiteral"] = 62] = "HexadecimalLiteral";
+  TokenType2[TokenType2["BinaryLiteral"] = 63] = "BinaryLiteral";
+  TokenType2[TokenType2["RealLiteral"] = 64] = "RealLiteral";
+  TokenType2[TokenType2["StringLiteral"] = 65] = "StringLiteral";
+  TokenType2[TokenType2["Infinity"] = 66] = "Infinity";
+  TokenType2[TokenType2["NaN"] = 67] = "NaN";
+  TokenType2[TokenType2["True"] = 68] = "True";
+  TokenType2[TokenType2["False"] = 69] = "False";
+  TokenType2[TokenType2["Typeof"] = 70] = "Typeof";
+  TokenType2[TokenType2["Null"] = 71] = "Null";
+  TokenType2[TokenType2["Undefined"] = 72] = "Undefined";
+  TokenType2[TokenType2["In"] = 73] = "In";
+  TokenType2[TokenType2["Instanceof"] = 74] = "Instanceof";
   TokenType2[TokenType2["Let"] = 75] = "Let";
   TokenType2[TokenType2["Const"] = 76] = "Const";
   TokenType2[TokenType2["Var"] = 77] = "Var";
@@ -724,7 +724,7 @@ class Lexer {
    * Call this after the first opening backing and after the parser is done with parsing a placeholder, after the right brace.
    */
   setStartingPhaseToTemplateLiteral() {
-    this._phaseExternallySet = 34;
+    this._phaseExternallySet = 33;
   }
   /**
    * Fetches the next character from the input stream
@@ -797,19 +797,19 @@ class Lexer {
               tokenType = TokenType.Multiply;
               break;
             case "%":
-              phase = 54;
+              phase = 53;
               tokenType = TokenType.Remainder;
               break;
             case "+":
-              phase = 51;
+              phase = 50;
               tokenType = TokenType.Plus;
               break;
             case "-":
-              phase = 52;
+              phase = 51;
               tokenType = TokenType.Minus;
               break;
             case "^":
-              phase = 58;
+              phase = 57;
               tokenType = TokenType.BitwiseXor;
               break;
             // --- BitwiseOr, LogicalOr
@@ -824,7 +824,7 @@ class Lexer {
               break;
             // --- "?", "?", or "?."
             case "?":
-              phase = 22;
+              phase = 21;
               tokenType = TokenType.QuestionMark;
               break;
             case ";":
@@ -835,11 +835,9 @@ class Lexer {
               return completeToken(TokenType.LParent);
             case ")":
               return completeToken(TokenType.RParent);
-            // --- ":" or "::"
+            // --- ":"
             case ":":
-              phase = 20;
-              tokenType = TokenType.Colon;
-              break;
+              return completeToken(TokenType.Colon);
             case "`":
               return completeToken(TokenType.Backtick);
             case "[":
@@ -874,7 +872,7 @@ class Lexer {
               break;
             // --- Decimal or Real literal
             case "0":
-              phase = 21;
+              phase = 20;
               tokenType = TokenType.DecimalLiteral;
               break;
             case ".":
@@ -885,7 +883,7 @@ class Lexer {
             case '"':
             case "'":
               stringState = ch;
-              phase = 35;
+              phase = 34;
               break;
             default:
               if (isIdStart(ch)) {
@@ -893,7 +891,7 @@ class Lexer {
                 phase = 17;
                 tokenType = TokenType.Identifier;
               } else if (isDecimalDigit(ch)) {
-                phase = 27;
+                phase = 26;
                 tokenType = TokenType.DecimalLiteral;
               } else {
                 completeToken(TokenType.Unknown);
@@ -935,8 +933,6 @@ class Lexer {
           break;
         // ====================================================================
         // Process miscellaneous tokens
-        case 20:
-          return ch === ":" ? completeToken(TokenType.Global) : makeToken();
         case 5:
           if (ch === "*") {
             phase = 3;
@@ -949,58 +945,58 @@ class Lexer {
             return makeToken();
           }
           break;
-        case 51:
+        case 50:
           if (ch === "+") {
             return completeToken(TokenType.IncOp);
           }
           return ch === "=" ? completeToken(TokenType.AddAssignment) : makeToken();
-        case 52:
+        case 51:
           if (ch === "-") {
             return completeToken(TokenType.DecOp);
           }
           return ch === "=" ? completeToken(TokenType.SubtractAssignment) : makeToken();
-        case 54:
+        case 53:
           return ch === "=" ? completeToken(TokenType.RemainderAssignment) : makeToken();
-        case 58:
+        case 57:
           return ch === "=" ? completeToken(TokenType.BitwiseXorAssignment) : makeToken();
         case 7:
           if (ch === "=") {
             return completeToken(TokenType.BitwiseOrAssignment);
           }
           if (ch === "|") {
-            phase = 59;
+            phase = 58;
             tokenType = TokenType.LogicalOr;
             break;
           }
           return makeToken();
-        case 59:
+        case 58:
           return ch === "=" ? completeToken(TokenType.LogicalOrAssignment) : makeToken();
         case 9:
           if (ch === "=") {
             return completeToken(TokenType.BitwiseAndAssignment);
           }
           if (ch === "&") {
-            phase = 57;
+            phase = 56;
             tokenType = TokenType.LogicalAnd;
             break;
           }
           return makeToken();
-        case 57:
+        case 56:
           return ch === "=" ? completeToken(TokenType.LogicalAndAssignment) : makeToken();
         case 8:
           if (ch === "*") {
-            phase = 50;
+            phase = 49;
             tokenType = TokenType.Exponent;
             break;
           } else if (ch === "=") {
             return completeToken(TokenType.MultiplyAssignment);
           }
           return makeToken();
-        case 50:
+        case 49:
           return ch === "=" ? completeToken(TokenType.ExponentAssignment) : makeToken();
-        case 22:
+        case 21:
           if (ch === "?") {
-            phase = 60;
+            phase = 59;
             tokenType = TokenType.NullCoalesce;
             break;
           }
@@ -1008,7 +1004,7 @@ class Lexer {
             return completeToken(TokenType.OptionalChaining);
           }
           return makeToken();
-        case 60:
+        case 59:
           return ch === "=" ? completeToken(TokenType.NullCoalesceAssignment) : makeToken();
         case 10:
           if (ch === ">") {
@@ -1036,12 +1032,12 @@ class Lexer {
             return completeToken(TokenType.LessThanOrEqual);
           }
           if (ch === "<") {
-            phase = 55;
+            phase = 54;
             tokenType = TokenType.ShiftLeft;
             break;
           }
           return makeToken();
-        case 55:
+        case 54:
           return ch === "=" ? completeToken(TokenType.ShiftLeftAssignment) : makeToken();
         case 15:
           if (ch === "=") {
@@ -1055,7 +1051,7 @@ class Lexer {
           return makeToken();
         case 16:
           if (ch === ">") {
-            phase = 56;
+            phase = 55;
             tokenType = TokenType.ShiftRight;
             break;
           }
@@ -1063,24 +1059,24 @@ class Lexer {
             return completeToken(TokenType.SignedShiftRightAssignment);
           }
           return makeToken();
-        case 56:
+        case 55:
           return ch === "=" ? completeToken(TokenType.ShiftRightAssignment) : makeToken();
         // ====================================================================
         // --- Literals
-        case 21:
+        case 20:
           if (ch === "x") {
-            phase = 23;
+            phase = 22;
             tokenType = TokenType.Unknown;
           } else if (ch === "b") {
-            phase = 25;
+            phase = 24;
             tokenType = TokenType.Unknown;
           } else if (isDecimalDigit(ch) || ch === "_") {
-            phase = 27;
+            phase = 26;
           } else if (ch === ".") {
-            phase = 28;
+            phase = 27;
             tokenType = TokenType.Unknown;
           } else if (ch === "e" || ch === "E") {
-            phase = 30;
+            phase = 29;
             tokenType = TokenType.Unknown;
           } else {
             return makeToken();
@@ -1095,92 +1091,92 @@ class Lexer {
           if (!isDecimalDigit(ch)) {
             return makeToken();
           }
-          phase = 29;
+          phase = 28;
           tokenType = TokenType.RealLiteral;
           break;
         case 19:
           return ch === "." ? completeToken(TokenType.Spread) : makeToken();
-        case 23:
+        case 22:
           if (ch === "_") {
             break;
           }
           if (!isHexadecimalDigit(ch)) {
             return makeToken();
           }
-          phase = 24;
+          phase = 23;
           tokenType = TokenType.HexadecimalLiteral;
           break;
-        case 24:
+        case 23:
           if (!isHexadecimalDigit(ch) && ch !== "_") {
             return makeToken();
           }
           break;
-        case 25:
+        case 24:
           if (ch === "_") {
             break;
           }
           if (!isBinaryDigit(ch)) {
             return makeToken();
           }
-          phase = 26;
+          phase = 25;
           tokenType = TokenType.BinaryLiteral;
           break;
-        case 26:
+        case 25:
           if (!isBinaryDigit(ch) && ch !== "_") {
             return makeToken();
           }
           tokenType = TokenType.BinaryLiteral;
           break;
-        case 27:
+        case 26:
           if (isDecimalDigit(ch) || ch === "_") {
             break;
           } else if (ch === "." && (this.input.peek() === null || isDecimalDigit(this.input.peek()))) {
-            phase = 28;
+            phase = 27;
             tokenType = TokenType.Unknown;
           } else if (ch === "e" || ch === "E") {
-            phase = 30;
+            phase = 29;
             tokenType = TokenType.Unknown;
           } else {
             return makeToken();
           }
           break;
-        case 28:
+        case 27:
           if (isDecimalDigit(ch)) {
-            phase = 29;
+            phase = 28;
             tokenType = TokenType.RealLiteral;
           } else if (ch === "e" || ch === "E") {
-            phase = 30;
+            phase = 29;
           } else {
             return makeToken();
           }
           break;
-        case 29:
+        case 28:
           if (ch === "e" || ch === "E") {
-            phase = 30;
+            phase = 29;
             tokenType = TokenType.Unknown;
           } else if (!isDecimalDigit(ch) && ch !== "_") {
             return makeToken();
           }
           break;
-        case 30:
+        case 29:
           if (ch === "+" || ch === "-") {
-            phase = 31;
+            phase = 30;
           } else if (isDecimalDigit(ch)) {
-            phase = 32;
+            phase = 31;
             tokenType = TokenType.RealLiteral;
           } else {
             return makeToken();
           }
           break;
-        case 31:
+        case 30:
           if (isDecimalDigit(ch)) {
-            phase = 32;
+            phase = 31;
             tokenType = TokenType.RealLiteral;
           } else {
             return makeToken();
           }
           break;
-        case 32:
+        case 31:
           if (!isDecimalDigit(ch)) {
             return makeToken();
           }
@@ -1197,8 +1193,8 @@ class Lexer {
             makeToken();
           }
           break;
-        case 33: {
-          phase = 34;
+        case 32: {
+          phase = 33;
           const charAhead12 = this.input.ahead(0);
           const charAhead22 = this.input.ahead(1);
           if (charAhead12 === "`" || charAhead12 === "$" && charAhead22 === "{") {
@@ -1206,10 +1202,10 @@ class Lexer {
           }
           break;
         }
-        case 34:
+        case 33:
           switch (ch) {
             case "\\":
-              phase = 33;
+              phase = 32;
               tokenType = TokenType.Unknown;
               break phaseSwitch;
             case "`":
@@ -1228,18 +1224,18 @@ class Lexer {
             return completeToken(TokenType.StringLiteral);
           }
           break;
-        case 35:
+        case 34:
           if (ch === stringState) {
             return completeToken(TokenType.StringLiteral);
           } else if (isRestrictedInString(ch)) {
             return completeToken(TokenType.Unknown);
           } else if (ch === "\\") {
-            phase = 36;
+            phase = 35;
             tokenType = TokenType.Unknown;
           }
           break;
         // Start of string character escape
-        case 36:
+        case 35:
           switch (ch) {
             case "b":
             case "f":
@@ -1253,133 +1249,133 @@ class Lexer {
             case '"':
             case "`":
             case "\\":
-              phase = 35;
+              phase = 34;
               break;
             case "x":
-              phase = 37;
+              phase = 36;
               break;
             case "u":
-              phase = 39;
+              phase = 38;
               break;
             default:
-              phase = 35;
+              phase = 34;
               break;
           }
           break;
         // --- First hexadecimal digit of string character escape
-        case 37:
+        case 36:
           if (isHexadecimalDigit(ch)) {
-            phase = 38;
+            phase = 37;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Second hexadecimal digit of character escape
-        case 38:
+        case 37:
           if (isHexadecimalDigit(ch)) {
-            phase = 35;
+            phase = 34;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- First hexadecimal digit of Unicode string character escape
-        case 39:
+        case 38:
           if (ch === "{") {
-            phase = 43;
+            phase = 42;
             break;
           }
           if (isHexadecimalDigit(ch)) {
-            phase = 40;
+            phase = 39;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Second hexadecimal digit of Unicode string character escape
-        case 40:
+        case 39:
           if (isHexadecimalDigit(ch)) {
-            phase = 41;
+            phase = 40;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Third hexadecimal digit of Unicode string character escape
-        case 41:
+        case 40:
           if (isHexadecimalDigit(ch)) {
-            phase = 42;
+            phase = 41;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Fourth hexadecimal digit of Unicode string character escape
-        case 42:
+        case 41:
           if (isHexadecimalDigit(ch)) {
-            phase = 35;
+            phase = 34;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- First hexadecimal digit of Unicode codepoint string character escape
-        case 43:
+        case 42:
           if (isHexadecimalDigit(ch)) {
-            phase = 44;
+            phase = 43;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Second hexadecimal digit of Unicode codepoint string character escape
-        case 44:
+        case 43:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else if (isHexadecimalDigit(ch)) {
-            phase = 45;
+            phase = 44;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Third hexadecimal digit of Unicode codepoint string character escape
-        case 45:
+        case 44:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else if (isHexadecimalDigit(ch)) {
-            phase = 46;
+            phase = 45;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Fourth hexadecimal digit of Unicode codepoint string character escape
-        case 46:
+        case 45:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else if (isHexadecimalDigit(ch)) {
-            phase = 47;
+            phase = 46;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Fifth hexadecimal digit of Unicode codepoint string character escape
-        case 47:
+        case 46:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else if (isHexadecimalDigit(ch)) {
-            phase = 48;
+            phase = 47;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Sixth hexadecimal digit of Unicode codepoint string character escape
-        case 48:
+        case 47:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else if (isHexadecimalDigit(ch)) {
-            phase = 49;
+            phase = 48;
           } else {
             return completeToken(TokenType.Unknown);
           }
           break;
         // --- Closing bracket of Unicode codepoint string character escape
-        case 49:
+        case 48:
           if (ch === "}") {
-            phase = 35;
+            phase = 34;
           } else {
             return completeToken(TokenType.Unknown);
           }
@@ -1492,6 +1488,7 @@ resolverHash.set("false", TokenType.False);
 resolverHash.set("undefined", TokenType.Undefined);
 resolverHash.set("null", TokenType.Null);
 resolverHash.set("in", TokenType.In);
+resolverHash.set("instanceof", TokenType.Instanceof);
 resolverHash.set("let", TokenType.Let);
 resolverHash.set("const", TokenType.Const);
 resolverHash.set("var", TokenType.Var);
@@ -1703,7 +1700,6 @@ const tokenTraits = {
   [TokenType.SignedShiftRight]: {},
   [TokenType.Dot]: {},
   [TokenType.Spread]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.Global]: { expressionStart: true },
   [TokenType.DecimalLiteral]: { expressionStart: true, isPropLiteral: true },
   [TokenType.HexadecimalLiteral]: { expressionStart: true, isPropLiteral: true },
   [TokenType.BinaryLiteral]: { expressionStart: true, isPropLiteral: true },
@@ -1719,6 +1715,7 @@ const tokenTraits = {
   [TokenType.Null]: { expressionStart: true, keywordLike: true },
   [TokenType.Undefined]: { expressionStart: true, keywordLike: true },
   [TokenType.In]: { keywordLike: true },
+  [TokenType.Instanceof]: { keywordLike: true },
   [TokenType.Let]: { keywordLike: true },
   [TokenType.Const]: { keywordLike: true },
   [TokenType.Var]: { keywordLike: true },
@@ -3683,7 +3680,7 @@ class Parser {
   }
   /**
    * relOrInExpr
-   *   : shiftExpr ( ( "<" | "<=" | ">" | ">=", "in" ) shiftExpr )?
+   *   : shiftExpr ( ( "<" | "<=" | ">" | ">=", "in", "instanceof" ) shiftExpr )?
    *   ;
    */
   parseRelOrInExpr() {
@@ -3698,7 +3695,8 @@ class Parser {
       TokenType.LessThanOrEqual,
       TokenType.GreaterThan,
       TokenType.GreaterThanOrEqual,
-      TokenType.In
+      TokenType.In,
+      TokenType.Instanceof
     )) {
       const rightExpr = this.parseShiftExpr();
       if (!rightExpr) {
@@ -4230,23 +4228,6 @@ class Parser {
           idToken
         );
       }
-      case TokenType.Global: {
-        this._lexer.get();
-        const idToken = this._lexer.get();
-        if (idToken.type !== TokenType.Identifier) {
-          this.reportError("W003");
-          return null;
-        }
-        return this.createExpressionNode(
-          T_IDENTIFIER,
-          {
-            name: idToken.text,
-            isGlobal: true
-          },
-          idToken,
-          idToken
-        );
-      }
       case TokenType.Backtick:
         return this.parseTemplateLiteral();
       case TokenType.False: