requirejs-esm 2.2.1 → 2.3.1

package/dist/plugin.js

@@ -180,7 +180,7 @@
       [8]: 'Octal literals are not allowed in strict mode',
       [7]: 'Decimal integer literals with a leading zero are forbidden in strict mode',
       [9]: 'Expected number in radix %0',
-      [145]: 'Invalid left-hand side assignment to a destructible right-hand side',
+      [146]: 'Invalid left-hand side assignment to a destructible right-hand side',
       [10]: 'Non-number found after exponent indicator',
       [11]: 'Invalid BigIntLiteral',
       [12]: 'No identifiers allowed directly after numeric literal',
@@ -201,9 +201,9 @@
       [27]: 'Member access on super must be in a method',
       [29]: 'Await expression not allowed in formal parameter',
       [30]: 'Yield expression not allowed in formal parameter',
-      [92]: "Unexpected token: 'escaped keyword'",
+      [93]: "Unexpected token: 'escaped keyword'",
       [31]: 'Unary expressions as the left operand of an exponentiation expression must be disambiguated with parentheses',
-      [119]: 'Async functions can only be declared at the top level or inside a block',
+      [120]: 'Async functions can only be declared at the top level or inside a block',
       [32]: 'Unterminated regular expression',
       [33]: 'Unexpected regular expression flag',
       [34]: "Duplicate regular expression flag '%0'",
@@ -213,125 +213,126 @@
       [38]: 'Function name may not contain any reserved words or be eval or arguments in strict mode',
       [39]: 'The rest operator is missing an argument',
       [40]: 'A getter cannot be a generator',
-      [41]: 'A computed property name must be followed by a colon or paren',
-      [130]: 'Object literal keys that are strings or numbers must be a method or have a colon',
-      [43]: 'Found `* async x(){}` but this should be `async * x(){}`',
-      [42]: 'Getters and setters can not be generators',
-      [44]: "'%0' can not be generator method",
-      [45]: "No line break is allowed after '=>'",
-      [46]: 'The left-hand side of the arrow can only be destructed through assignment',
-      [47]: 'The binding declaration is not destructible',
-      [48]: 'Async arrow can not be followed by new expression',
-      [49]: "Classes may not have a static property named 'prototype'",
-      [50]: 'Class constructor may not be a %0',
-      [51]: 'Duplicate constructor method in class',
-      [52]: 'Invalid increment/decrement operand',
-      [53]: 'Invalid use of `new` keyword on an increment/decrement expression',
-      [54]: '`=>` is an invalid assignment target',
-      [55]: 'Rest element may not have a trailing comma',
-      [56]: 'Missing initializer in %0 declaration',
-      [57]: "'for-%0' loop head declarations can not have an initializer",
-      [58]: 'Invalid left-hand side in for-%0 loop: Must have a single binding',
-      [59]: 'Invalid shorthand property initializer',
-      [60]: 'Property name __proto__ appears more than once in object literal',
-      [61]: 'Let is disallowed as a lexically bound name',
-      [62]: "Invalid use of '%0' inside new expression",
-      [63]: "Illegal 'use strict' directive in function with non-simple parameter list",
-      [64]: 'Identifier "let" disallowed as left-hand side expression in strict mode',
-      [65]: 'Illegal continue statement',
-      [66]: 'Illegal break statement',
-      [67]: 'Cannot have `let[...]` as a var name in strict mode',
-      [68]: 'Invalid destructuring assignment target',
-      [69]: 'Rest parameter may not have a default initializer',
-      [70]: 'The rest argument must the be last parameter',
-      [71]: 'Invalid rest argument',
-      [73]: 'In strict mode code, functions can only be declared at top level or inside a block',
-      [74]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
-      [75]: 'Without web compatibility enabled functions can not be declared at top level, inside a block, or as the body of an if statement',
-      [76]: "Class declaration can't appear in single-statement context",
-      [77]: 'Invalid left-hand side in for-%0',
-      [78]: 'Invalid assignment in for-%0',
-      [79]: 'for await (... of ...) is only valid in async functions and async generators',
-      [80]: 'The first token after the template expression should be a continuation of the template',
-      [82]: '`let` declaration not allowed here and `let` cannot be a regular var name in strict mode',
-      [81]: '`let \n [` is a restricted production at the start of a statement',
-      [83]: 'Catch clause requires exactly one parameter, not more (and no trailing comma)',
-      [84]: 'Catch clause parameter does not support default values',
-      [85]: 'Missing catch or finally after try',
-      [86]: 'More than one default clause in switch statement',
-      [87]: 'Illegal newline after throw',
-      [88]: 'Strict mode code may not include a with statement',
-      [89]: 'Illegal return statement',
-      [90]: 'The left hand side of the for-header binding declaration is not destructible',
-      [91]: 'new.target only allowed within functions',
-      [93]: "'#' not followed by identifier",
-      [99]: 'Invalid keyword',
-      [98]: "Can not use 'let' as a class name",
-      [97]: "'A lexical declaration can't define a 'let' binding",
-      [96]: 'Can not use `let` as variable name in strict mode',
-      [94]: "'%0' may not be used as an identifier in this context",
-      [95]: 'Await is only valid in async functions',
-      [100]: 'The %0 keyword can only be used with the module goal',
-      [101]: 'Unicode codepoint must not be greater than 0x10FFFF',
-      [102]: '%0 source must be string',
-      [103]: 'Only a identifier can be used to indicate alias',
-      [104]: "Only '*' or '{...}' can be imported after default",
-      [105]: 'Trailing decorator may be followed by method',
-      [106]: "Decorators can't be used with a constructor",
-      [108]: 'HTML comments are only allowed with web compatibility (Annex B)',
-      [109]: "The identifier 'let' must not be in expression position in strict mode",
-      [110]: 'Cannot assign to `eval` and `arguments` in strict mode',
-      [111]: "The left-hand side of a for-of loop may not start with 'let'",
-      [112]: 'Block body arrows can not be immediately invoked without a group',
-      [113]: 'Block body arrows can not be immediately accessed without a group',
-      [114]: 'Unexpected strict mode reserved word',
-      [115]: 'Unexpected eval or arguments in strict mode',
-      [116]: 'Decorators must not be followed by a semicolon',
-      [117]: 'Calling delete on expression not allowed in strict mode',
-      [118]: 'Pattern can not have a tail',
-      [120]: 'Can not have a `yield` expression on the left side of a ternary',
-      [121]: 'An arrow function can not have a postfix update operator',
-      [122]: 'Invalid object literal key character after generator star',
-      [123]: 'Private fields can not be deleted',
-      [125]: 'Classes may not have a field called constructor',
-      [124]: 'Classes may not have a private element named constructor',
-      [126]: 'A class field initializer may not contain arguments',
-      [127]: 'Generators can only be declared at the top level or inside a block',
-      [128]: 'Async methods are a restricted production and cannot have a newline following it',
-      [129]: 'Unexpected character after object literal property name',
-      [131]: 'Invalid key token',
-      [132]: "Label '%0' has already been declared",
-      [133]: 'continue statement must be nested within an iteration statement',
-      [134]: "Undefined label '%0'",
-      [135]: 'Trailing comma is disallowed inside import(...) arguments',
-      [136]: 'import() requires exactly one argument',
-      [137]: 'Cannot use new with import(...)',
-      [138]: '... is not allowed in import()',
-      [139]: "Expected '=>'",
-      [140]: "Duplicate binding '%0'",
-      [141]: "Cannot export a duplicate name '%0'",
-      [144]: 'Duplicate %0 for-binding',
-      [142]: "Exported binding '%0' needs to refer to a top-level declared variable",
-      [143]: 'Unexpected private field',
-      [147]: 'Numeric separators are not allowed at the end of numeric literals',
-      [146]: 'Only one underscore is allowed as numeric separator',
-      [148]: 'JSX value should be either an expression or a quoted JSX text',
-      [149]: 'Expected corresponding JSX closing tag for %0',
-      [150]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
-      [151]: "JSX attributes must only be assigned a non-empty 'expression'",
-      [152]: "'%0' has already been declared",
-      [153]: "'%0' shadowed a catch clause binding",
-      [154]: 'Dot property must be an identifier',
-      [155]: 'Encountered invalid input after spread/rest argument',
-      [156]: 'Catch without try',
-      [157]: 'Finally without try',
-      [158]: 'Expected corresponding closing tag for JSX fragment',
-      [159]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
-      [160]: 'Invalid tagged template on optional chain',
-      [161]: 'Invalid optional chain from super property',
-      [162]: 'Invalid optional chain from new expression',
-      [163]: 'Cannot use "import.meta" outside a module',
-      [164]: 'Leading decorators must be attached to a class declaration'
+      [41]: 'A setter cannot be a generator',
+      [42]: 'A computed property name must be followed by a colon or paren',
+      [131]: 'Object literal keys that are strings or numbers must be a method or have a colon',
+      [44]: 'Found `* async x(){}` but this should be `async * x(){}`',
+      [43]: 'Getters and setters can not be generators',
+      [45]: "'%0' can not be generator method",
+      [46]: "No line break is allowed after '=>'",
+      [47]: 'The left-hand side of the arrow can only be destructed through assignment',
+      [48]: 'The binding declaration is not destructible',
+      [49]: 'Async arrow can not be followed by new expression',
+      [50]: "Classes may not have a static property named 'prototype'",
+      [51]: 'Class constructor may not be a %0',
+      [52]: 'Duplicate constructor method in class',
+      [53]: 'Invalid increment/decrement operand',
+      [54]: 'Invalid use of `new` keyword on an increment/decrement expression',
+      [55]: '`=>` is an invalid assignment target',
+      [56]: 'Rest element may not have a trailing comma',
+      [57]: 'Missing initializer in %0 declaration',
+      [58]: "'for-%0' loop head declarations can not have an initializer",
+      [59]: 'Invalid left-hand side in for-%0 loop: Must have a single binding',
+      [60]: 'Invalid shorthand property initializer',
+      [61]: 'Property name __proto__ appears more than once in object literal',
+      [62]: 'Let is disallowed as a lexically bound name',
+      [63]: "Invalid use of '%0' inside new expression",
+      [64]: "Illegal 'use strict' directive in function with non-simple parameter list",
+      [65]: 'Identifier "let" disallowed as left-hand side expression in strict mode',
+      [66]: 'Illegal continue statement',
+      [67]: 'Illegal break statement',
+      [68]: 'Cannot have `let[...]` as a var name in strict mode',
+      [69]: 'Invalid destructuring assignment target',
+      [70]: 'Rest parameter may not have a default initializer',
+      [71]: 'The rest argument must the be last parameter',
+      [72]: 'Invalid rest argument',
+      [74]: 'In strict mode code, functions can only be declared at top level or inside a block',
+      [75]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+      [76]: 'Without web compatibility enabled functions can not be declared at top level, inside a block, or as the body of an if statement',
+      [77]: "Class declaration can't appear in single-statement context",
+      [78]: 'Invalid left-hand side in for-%0',
+      [79]: 'Invalid assignment in for-%0',
+      [80]: 'for await (... of ...) is only valid in async functions and async generators',
+      [81]: 'The first token after the template expression should be a continuation of the template',
+      [83]: '`let` declaration not allowed here and `let` cannot be a regular var name in strict mode',
+      [82]: '`let \n [` is a restricted production at the start of a statement',
+      [84]: 'Catch clause requires exactly one parameter, not more (and no trailing comma)',
+      [85]: 'Catch clause parameter does not support default values',
+      [86]: 'Missing catch or finally after try',
+      [87]: 'More than one default clause in switch statement',
+      [88]: 'Illegal newline after throw',
+      [89]: 'Strict mode code may not include a with statement',
+      [90]: 'Illegal return statement',
+      [91]: 'The left hand side of the for-header binding declaration is not destructible',
+      [92]: 'new.target only allowed within functions',
+      [94]: "'#' not followed by identifier",
+      [100]: 'Invalid keyword',
+      [99]: "Can not use 'let' as a class name",
+      [98]: "'A lexical declaration can't define a 'let' binding",
+      [97]: 'Can not use `let` as variable name in strict mode',
+      [95]: "'%0' may not be used as an identifier in this context",
+      [96]: 'Await is only valid in async functions',
+      [101]: 'The %0 keyword can only be used with the module goal',
+      [102]: 'Unicode codepoint must not be greater than 0x10FFFF',
+      [103]: '%0 source must be string',
+      [104]: 'Only a identifier can be used to indicate alias',
+      [105]: "Only '*' or '{...}' can be imported after default",
+      [106]: 'Trailing decorator may be followed by method',
+      [107]: "Decorators can't be used with a constructor",
+      [109]: 'HTML comments are only allowed with web compatibility (Annex B)',
+      [110]: "The identifier 'let' must not be in expression position in strict mode",
+      [111]: 'Cannot assign to `eval` and `arguments` in strict mode',
+      [112]: "The left-hand side of a for-of loop may not start with 'let'",
+      [113]: 'Block body arrows can not be immediately invoked without a group',
+      [114]: 'Block body arrows can not be immediately accessed without a group',
+      [115]: 'Unexpected strict mode reserved word',
+      [116]: 'Unexpected eval or arguments in strict mode',
+      [117]: 'Decorators must not be followed by a semicolon',
+      [118]: 'Calling delete on expression not allowed in strict mode',
+      [119]: 'Pattern can not have a tail',
+      [121]: 'Can not have a `yield` expression on the left side of a ternary',
+      [122]: 'An arrow function can not have a postfix update operator',
+      [123]: 'Invalid object literal key character after generator star',
+      [124]: 'Private fields can not be deleted',
+      [126]: 'Classes may not have a field called constructor',
+      [125]: 'Classes may not have a private element named constructor',
+      [127]: 'A class field initializer may not contain arguments',
+      [128]: 'Generators can only be declared at the top level or inside a block',
+      [129]: 'Async methods are a restricted production and cannot have a newline following it',
+      [130]: 'Unexpected character after object literal property name',
+      [132]: 'Invalid key token',
+      [133]: "Label '%0' has already been declared",
+      [134]: 'continue statement must be nested within an iteration statement',
+      [135]: "Undefined label '%0'",
+      [136]: 'Trailing comma is disallowed inside import(...) arguments',
+      [137]: 'import() requires exactly one argument',
+      [138]: 'Cannot use new with import(...)',
+      [139]: '... is not allowed in import()',
+      [140]: "Expected '=>'",
+      [141]: "Duplicate binding '%0'",
+      [142]: "Cannot export a duplicate name '%0'",
+      [145]: 'Duplicate %0 for-binding',
+      [143]: "Exported binding '%0' needs to refer to a top-level declared variable",
+      [144]: 'Unexpected private field',
+      [148]: 'Numeric separators are not allowed at the end of numeric literals',
+      [147]: 'Only one underscore is allowed as numeric separator',
+      [149]: 'JSX value should be either an expression or a quoted JSX text',
+      [150]: 'Expected corresponding JSX closing tag for %0',
+      [151]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+      [152]: "JSX attributes must only be assigned a non-empty 'expression'",
+      [153]: "'%0' has already been declared",
+      [154]: "'%0' shadowed a catch clause binding",
+      [155]: 'Dot property must be an identifier',
+      [156]: 'Encountered invalid input after spread/rest argument',
+      [157]: 'Catch without try',
+      [158]: 'Finally without try',
+      [159]: 'Expected corresponding closing tag for JSX fragment',
+      [160]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
+      [161]: 'Invalid tagged template on optional chain',
+      [162]: 'Invalid optional chain from super property',
+      [163]: 'Invalid optional chain from new expression',
+      [164]: 'Cannot use "import.meta" outside a module',
+      [165]: 'Leading decorators must be attached to a class declaration'
   };
   class ParseError extends SyntaxError {
       constructor(startindex, line, column, type, ...params) {
@@ -1033,7 +1034,7 @@
                   break;
               case 117:
                   if (mask & 16)
-                      report(parser, 34, 'g');
+                      report(parser, 34, 'u');
                   mask |= 16;
                   break;
               case 121:
@@ -1046,6 +1047,11 @@
                       report(parser, 34, 's');
                   mask |= 32;
                   break;
+              case 100:
+                  if (mask & 64)
+                      report(parser, 34, 'd');
+                  mask |= 64;
+                  break;
               default:
                   report(parser, 33);
           }
@@ -1064,7 +1070,13 @@
           return new RegExp(pattern, flags);
       }
       catch (e) {
-          report(parser, 32);
+          try {
+              new RegExp(pattern, flags.replace('d', ''));
+              return null;
+          }
+          catch (e) {
+              report(parser, 32);
+          }
       }
   }
 
@@ -1252,7 +1264,7 @@
           case -4:
               report(state, 6);
           case -5:
-              report(state, 101);
+              report(state, 102);
       }
   }
 
@@ -1365,7 +1377,7 @@
                   while (CharTypes[char] & (64 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator)
-                              report(parser, 146);
+                              report(parser, 147);
                           allowSeparator = 0;
                           char = advanceChar(parser);
                           continue;
@@ -1375,8 +1387,8 @@
                       digits++;
                       char = advanceChar(parser);
                   }
-                  if (digits < 1 || !allowSeparator) {
-                      report(parser, digits < 1 ? 19 : 147);
+                  if (digits === 0 || !allowSeparator) {
+                      report(parser, digits === 0 ? 19 : 148);
                   }
               }
               else if ((char | 32) === 111) {
@@ -1385,7 +1397,7 @@
                   while (CharTypes[char] & (32 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              report(parser, 146);
+                              report(parser, 147);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1396,8 +1408,8 @@
                       digits++;
                       char = advanceChar(parser);
                   }
-                  if (digits < 1 || !allowSeparator) {
-                      report(parser, digits < 1 ? 0 : 147);
+                  if (digits === 0 || !allowSeparator) {
+                      report(parser, digits === 0 ? 0 : 148);
                   }
               }
               else if ((char | 32) === 98) {
@@ -1406,7 +1418,7 @@
                   while (CharTypes[char] & (128 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              report(parser, 146);
+                              report(parser, 147);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1417,8 +1429,8 @@
                       digits++;
                       char = advanceChar(parser);
                   }
-                  if (digits < 1 || !allowSeparator) {
-                      report(parser, digits < 1 ? 0 : 147);
+                  if (digits === 0 || !allowSeparator) {
+                      report(parser, digits === 0 ? 0 : 148);
                   }
               }
               else if (CharTypes[char] & 32) {
@@ -1451,7 +1463,7 @@
                       if (char === 95) {
                           char = advanceChar(parser);
                           if (char === 95 || kind & 32) {
-                              reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+                              reportScannerError(parser.index, parser.line, parser.index + 1, 147);
                           }
                           allowSeparator = 1;
                           continue;
@@ -1462,7 +1474,7 @@
                       --digit;
                   }
                   if (allowSeparator) {
-                      reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+                      reportScannerError(parser.index, parser.line, parser.index + 1, 148);
                   }
                   if (digit >= 0 && !isIdentifierStart$1(char) && char !== 46) {
                       parser.tokenValue = value;
@@ -1494,7 +1506,7 @@
               if (CharTypes[char] & 256)
                   char = advanceChar(parser);
               const { index } = parser;
-              if ((CharTypes[char] & 16) < 1)
+              if ((CharTypes[char] & 16) === 0)
                   report(parser, 10);
               value += parser.source.substring(end, index) + scanDecimalDigitsOrSeparator(parser, char);
               char = parser.currentChar;
@@ -1527,7 +1539,7 @@
               const { index } = parser;
               char = advanceChar(parser);
               if (char === 95) {
-                  reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+                  reportScannerError(parser.index, parser.line, parser.index + 1, 147);
               }
               allowSeparator = 1;
               ret += parser.source.substring(start, index);
@@ -1538,7 +1550,7 @@
           char = advanceChar(parser);
       }
       if (allowSeparator) {
-          reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+          reportScannerError(parser.index, parser.line, parser.index + 1, 148);
       }
       return ret + parser.source.substring(start, parser.index);
   }
@@ -1627,7 +1639,7 @@
   function scanIdentifier(parser, context, isValidAsKeyword) {
       while (isIdPart[advanceChar(parser)]) { }
       parser.tokenValue = parser.source.slice(parser.tokenPos, parser.index);
-      return parser.currentChar !== 92 && parser.currentChar < 0x7e
+      return parser.currentChar !== 92 && parser.currentChar <= 0x7e
           ? descKeywordTable[parser.tokenValue] || 208897
           : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
   }
@@ -1668,14 +1680,28 @@
               return 208897;
           if (!hasEscape)
               return token;
+          if (token === 209008) {
+              if ((context & (2048 | 4194304)) === 0) {
+                  return token;
+              }
+              return 121;
+          }
           if (context & 1024) {
-              return token === 209008 && (context & (2048 | 4194304)) === 0
-                  ? token
-                  : token === 36972
-                      ? 122
-                      : (token & 36864) === 36864
-                          ? 122
-                          : 121;
+              if (token === 36972) {
+                  return 122;
+              }
+              if ((token & 36864) === 36864) {
+                  return 122;
+              }
+              if ((token & 20480) === 20480) {
+                  if (context & 1073741824 && (context & 8192) === 0) {
+                      return token;
+                  }
+                  else {
+                      return 121;
+                  }
+              }
+              return 143483;
           }
           if (context & 1073741824 &&
               (context & 8192) === 0 &&
@@ -1688,19 +1714,19 @@
                       ? 121
                       : token;
           }
-          return token === 209007 && context & 1073741824
-              ? 143483
-              : (token & 36864) === 36864
-                  ? token
-                  : token === 209008 && (context & 4194304) === 0
-                      ? token
-                      : 121;
+          if (token === 209007) {
+              return 143483;
+          }
+          if ((token & 36864) === 36864) {
+              return token;
+          }
+          return 121;
       }
       return 208897;
   }
   function scanPrivateIdentifier(parser) {
       if (!isIdentifierStart$1(advanceChar(parser)))
-          report(parser, 93);
+          report(parser, 94);
       return 131;
   }
   function scanIdentifierUnicodeEscape(parser) {
@@ -1718,7 +1744,7 @@
           while (CharTypes[advanceChar(parser)] & 64) {
               codePoint = (codePoint << 4) | toHex(parser.currentChar);
               if (codePoint > 1114111)
-                  reportScannerError(begin, parser.line, parser.index + 1, 101);
+                  reportScannerError(begin, parser.line, parser.index + 1, 102);
           }
           if (parser.currentChar !== 125) {
               reportScannerError(begin, parser.line, parser.index - 1, 6);
@@ -1975,7 +2001,7 @@
                               return 8456258;
                           }
                           if (ch === 47) {
-                              if ((context & 16) < 1)
+                              if ((context & 16) === 0)
                                   return 8456258;
                               const index = parser.index + 1;
                               if (index < parser.end) {
@@ -2059,7 +2085,7 @@
                           advanceChar(parser);
                           if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
                               if ((context & 256) === 0)
-                                  report(parser, 108);
+                                  report(parser, 109);
                               advanceChar(parser);
                               state = skipSingleHTMLComment(parser, source, state, context, 3, startPos, startLine, startColumn);
                               startPos = parser.tokenPos;
@@ -4555,7 +4581,7 @@
           case 'AssignmentExpression':
               node.type = 'AssignmentPattern';
               if (node.operator !== '=')
-                  report(state, 68);
+                  report(state, 69);
               delete node.operator;
               reinterpretToPattern(state, node.left);
               return;
@@ -4570,58 +4596,58 @@
   function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
       if (context & 1024) {
           if ((t & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
       }
       if ((t & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (kind & (8 | 16) && t === 241739) {
-          report(parser, 97);
+          report(parser, 98);
       }
       if (context & (4194304 | 2048) && t === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       if (context & (2097152 | 1024) && t === 241773) {
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       }
   }
   function validateFunctionName(parser, context, t) {
       if (context & 1024) {
           if ((t & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if ((t & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
           if (t === 122) {
-              report(parser, 92);
+              report(parser, 93);
           }
           if (t === 121) {
-              report(parser, 92);
+              report(parser, 93);
           }
       }
       if ((t & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (context & (4194304 | 2048) && t === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       if (context & (2097152 | 1024) && t === 241773) {
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       }
   }
   function isStrictReservedWord$1(parser, context, t) {
       if (t === 209008) {
           if (context & (4194304 | 2048))
-              report(parser, 95);
+              report(parser, 96);
           parser.destructible |= 128;
       }
       if (t === 241773 && context & 2097152)
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       return ((t & 20480) === 20480 ||
           (t & 36864) === 36864 ||
           t == 122);
@@ -4633,7 +4659,7 @@
       while (labels) {
           if (labels['$' + name]) {
               if (isIterationStatement)
-                  report(parser, 133);
+                  report(parser, 134);
               return 1;
           }
           if (isIterationStatement && labels.loop)
@@ -4646,7 +4672,7 @@
       let set = labels;
       while (set) {
           if (set['$' + name])
-              report(parser, 132, name);
+              report(parser, 133, name);
           set = set['$'];
       }
       labels['$' + name] = 1;
@@ -4727,27 +4753,27 @@
       const value = scope['#' + name];
       if (value && (value & 2) === 0) {
           if (kind & 1) {
-              scope.scopeError = recordScopeError(parser, 140, name);
+              scope.scopeError = recordScopeError(parser, 141, name);
           }
           else if (context & 256 &&
               value & 64 &&
               origin & 2) ;
           else {
-              report(parser, 140, name);
+              report(parser, 141, name);
           }
       }
       if (scope.type & 128 &&
           (scope.parent['#' + name] && (scope.parent['#' + name] & 2) === 0)) {
-          report(parser, 140, name);
+          report(parser, 141, name);
       }
       if (scope.type & 1024 && value && (value & 2) === 0) {
           if (kind & 1) {
-              scope.scopeError = recordScopeError(parser, 140, name);
+              scope.scopeError = recordScopeError(parser, 141, name);
           }
       }
       if (scope.type & 64) {
           if (scope.parent['#' + name] & 768)
-              report(parser, 153, name);
+              report(parser, 154, name);
       }
       scope['#' + name] = kind;
   }
@@ -4761,19 +4787,19 @@
                   ((kind & 128 && value & 68) ||
                       (value & 128 && kind & 68))) ;
               else {
-                  report(parser, 140, name);
+                  report(parser, 141, name);
               }
           }
           if (currentScope === scope) {
               if (value & 1 && kind & 1) {
-                  currentScope.scopeError = recordScopeError(parser, 140, name);
+                  currentScope.scopeError = recordScopeError(parser, 141, name);
               }
           }
           if (value & (512 | 256)) {
               if ((value & 512) === 0 ||
                   (context & 256) === 0 ||
                   context & 1024) {
-                  report(parser, 140, name);
+                  report(parser, 141, name);
               }
           }
           currentScope['#' + name] = kind;
@@ -4783,7 +4809,7 @@
   function declareUnboundVariable(parser, name) {
       if (parser.exportedNames !== void 0 && name !== '') {
           if (parser.exportedNames['#' + name]) {
-              report(parser, 141, name);
+              report(parser, 142, name);
           }
           parser.exportedNames['#' + name] = 1;
       }
@@ -4841,7 +4867,7 @@
   function classifyIdentifier(parser, context, t, isArrow) {
       if ((t & 537079808) === 537079808) {
           if (context & 1024)
-              report(parser, 115);
+              report(parser, 116);
           if (isArrow)
               parser.flags |= 512;
       }
@@ -4934,7 +4960,7 @@
           if (scope) {
               for (const key in parser.exportedBindings) {
                   if (key[0] === '#' && !scope[key])
-                      report(parser, 142, key.slice(1));
+                      report(parser, 143, key.slice(1));
               }
           }
       }
@@ -5004,7 +5030,7 @@
               moduleItem = parseStatementListItem(parser, context, scope, 4, {});
       }
       if (parser.leadingDecorators.length) {
-          report(parser, 164);
+          report(parser, 165);
       }
       return moduleItem;
   }
@@ -5023,7 +5049,7 @@
           case 241739:
               return parseLetIdentOrVarDeclarationStatement(parser, context, scope, origin, start, line, column);
           case 20566:
-              report(parser, 100, 'export');
+              report(parser, 101, 'export');
           case 86108:
               nextToken(parser, context);
               switch (parser.token) {
@@ -5032,7 +5058,7 @@
                   case 67108877:
                       return parseImportMetaDeclaration(parser, context, start, line, column);
                   default:
-                      report(parser, 100, 'import');
+                      report(parser, 101, 'import');
               }
           case 209007:
               return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 1, start, line, column);
@@ -5075,17 +5101,17 @@
           case 209007:
               return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 0, start, line, column);
           case 20559:
-              report(parser, 156);
-          case 20568:
               report(parser, 157);
+          case 20568:
+              report(parser, 158);
           case 86106:
               report(parser, context & 1024
-                  ? 73
-                  : (context & 256) < 1
-                      ? 75
-                      : 74);
+                  ? 74
+                  : (context & 256) === 0
+                      ? 76
+                      : 75);
           case 86096:
-              report(parser, 76);
+              report(parser, 77);
           default:
               return parseExpressionOrLabelledStatement(parser, context, scope, origin, labels, allowFuncDecl, start, line, column);
       }
@@ -5097,9 +5123,9 @@
           case 241739:
               expr = parseIdentifier(parser, context, 0);
               if (context & 1024)
-                  report(parser, 82);
+                  report(parser, 83);
               if (parser.token === 69271571)
-                  report(parser, 81);
+                  report(parser, 82);
               break;
           default:
               expr = parsePrimaryExpression(parser, context, 2, 0, 1, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
@@ -5127,8 +5153,8 @@
       });
   }
   function parseReturnStatement(parser, context, start, line, column) {
-      if ((context & 32) < 1 && context & 8192)
-          report(parser, 89);
+      if ((context & 32) === 0 && context & 8192)
+          report(parser, 90);
       nextToken(parser, context | 32768);
       const argument = parser.flags & 1 || parser.token & 1048576
           ? null
@@ -5151,7 +5177,7 @@
       validateAndDeclareLabel(parser, labels, value);
       nextToken(parser, context | 32768);
       const body = allowFuncDecl &&
-          (context & 1024) < 1 &&
+          (context & 1024) === 0 &&
           context & 256 &&
           parser.token === 86106
           ? parseFunctionDeclaration(parser, context, addChildScope(scope, 2), origin, 0, 0, 0, parser.tokenPos, parser.linePos, parser.colPos)
@@ -5172,7 +5198,7 @@
       if (!asyncNewLine) {
           if (parser.token === 86106) {
               if (!allowFuncDecl)
-                  report(parser, 119);
+                  report(parser, 120);
               return parseFunctionDeclaration(parser, context, scope, origin, 1, 0, 1, start, line, column);
           }
           if ((parser.token & 143360) === 143360) {
@@ -5231,7 +5257,7 @@
   function parseThrowStatement(parser, context, start, line, column) {
       nextToken(parser, context | 32768);
       if (parser.flags & 1)
-          report(parser, 87);
+          report(parser, 88);
       const argument = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5260,7 +5286,7 @@
   }
   function parseConsequentOrAlternative(parser, context, scope, labels, start, line, column) {
       return context & 1024 ||
-          (context & 256) < 1 ||
+          (context & 256) === 0 ||
           parser.token !== 86106
           ? parseStatement(parser, context, scope, 0, { $: labels }, 0, parser.tokenPos, parser.linePos, parser.colPos)
           : parseFunctionDeclaration(parser, context, addChildScope(scope, 2), 0, 0, 0, 0, start, line, column);
@@ -5285,7 +5311,7 @@
           else {
               consume(parser, context | 32768, 20563);
               if (seenDefault)
-                  report(parser, 86);
+                  report(parser, 87);
               seenDefault = 1;
           }
           consume(parser, context | 32768, 21);
@@ -5325,15 +5351,15 @@
       return parseStatement(parser, ((context | 134217728) ^ 134217728) | 131072, scope, 0, { loop: 1, $: labels }, 0, parser.tokenPos, parser.linePos, parser.colPos);
   }
   function parseContinueStatement(parser, context, labels, start, line, column) {
-      if ((context & 131072) < 1)
-          report(parser, 65);
+      if ((context & 131072) === 0)
+          report(parser, 66);
       nextToken(parser, context);
       let label = null;
-      if ((parser.flags & 1) < 1 && parser.token & 143360) {
+      if ((parser.flags & 1) === 0 && parser.token & 143360) {
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32768, 0);
           if (!isValidLabel(parser, labels, tokenValue, 1))
-              report(parser, 134, tokenValue);
+              report(parser, 135, tokenValue);
       }
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5344,14 +5370,14 @@
   function parseBreakStatement(parser, context, labels, start, line, column) {
       nextToken(parser, context | 32768);
       let label = null;
-      if ((parser.flags & 1) < 1 && parser.token & 143360) {
+      if ((parser.flags & 1) === 0 && parser.token & 143360) {
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32768, 0);
           if (!isValidLabel(parser, labels, tokenValue, 0))
-              report(parser, 134, tokenValue);
+              report(parser, 135, tokenValue);
       }
-      else if ((context & (4096 | 131072)) < 1) {
-          report(parser, 66);
+      else if ((context & (4096 | 131072)) === 0) {
+          report(parser, 67);
       }
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5362,7 +5388,7 @@
   function parseWithStatement(parser, context, scope, labels, start, line, column) {
       nextToken(parser, context);
       if (context & 1024)
-          report(parser, 88);
+          report(parser, 89);
       consume(parser, context | 32768, 67174411);
       const object = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
       consume(parser, context | 32768, 16);
@@ -5395,7 +5421,7 @@
           finalizer = parseBlock(parser, context, finalizerScope, { $: labels }, parser.tokenPos, parser.linePos, parser.colPos);
       }
       if (!handler && !finalizer) {
-          report(parser, 85);
+          report(parser, 86);
       }
       return finishNode(parser, context, start, line, column, {
           type: 'TryStatement',
@@ -5414,10 +5440,10 @@
               ? 256
               : 512, 0, parser.tokenPos, parser.linePos, parser.colPos);
           if (parser.token === 18) {
-              report(parser, 83);
+              report(parser, 84);
           }
           else if (parser.token === 1077936157) {
-              report(parser, 84);
+              report(parser, 85);
           }
           consume(parser, context | 32768, 16);
           if (scope)
@@ -5430,6 +5456,17 @@
           body
       });
   }
+  function parseStaticBlock(parser, context, scope, start, line, column) {
+      if (scope)
+          scope = addChildScope(scope, 2);
+      const ctorContext = 16384 | 524288;
+      context = ((context | ctorContext) ^ ctorContext) | 262144;
+      const { body } = parseBlock(parser, context, scope, {}, start, line, column);
+      return finishNode(parser, context, start, line, column, {
+          type: 'StaticBlock',
+          body
+      });
+  }
   function parseDoWhileStatement(parser, context, scope, labels, start, line, column) {
       nextToken(parser, context | 32768);
       const body = parseIterationStatementBody(parser, context, scope, labels);
@@ -5458,7 +5495,7 @@
       }
       parser.assignable = 1;
       if (context & 1024)
-          report(parser, 82);
+          report(parser, 83);
       if (parser.token === 21) {
           return parseLabelledStatement(parser, context, scope, origin, {}, tokenValue, expr, token, 0, start, line, column);
       }
@@ -5506,7 +5543,7 @@
           list.push(parseVariableDeclaration(parser, context, scope, kind, origin));
       }
       if (bindingCount > 1 && origin & 32 && parser.token & 262144) {
-          report(parser, 58, KeywordDescTable[parser.token & 255]);
+          report(parser, 59, KeywordDescTable[parser.token & 255]);
       }
       return list;
   }
@@ -5517,17 +5554,17 @@
       if (parser.token === 1077936157) {
           nextToken(parser, context | 32768);
           init = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
-          if (origin & 32 || (token & 2097152) < 1) {
+          if (origin & 32 || (token & 2097152) === 0) {
               if (parser.token === 274549 ||
                   (parser.token === 8738868 &&
-                      (token & 2097152 || (kind & 4) < 1 || context & 1024))) {
-                  reportMessageAt(tokenPos, parser.line, parser.index - 3, 57, parser.token === 274549 ? 'of' : 'in');
+                      (token & 2097152 || (kind & 4) === 0 || context & 1024))) {
+                  reportMessageAt(tokenPos, parser.line, parser.index - 3, 58, parser.token === 274549 ? 'of' : 'in');
               }
           }
       }
       else if ((kind & 16 || (token & 2097152) > 0) &&
           (parser.token & 262144) !== 262144) {
-          report(parser, 56, kind & 16 ? 'const' : 'destructuring');
+          report(parser, 57, kind & 16 ? 'const' : 'destructuring');
       }
       return finishNode(parser, context, tokenPos, linePos, colPos, {
           type: 'VariableDeclarator',
@@ -5537,7 +5574,8 @@
   }
   function parseForStatement(parser, context, scope, labels, start, line, column) {
       nextToken(parser, context);
-      const forAwait = (context & 4194304) > 0 && consumeOpt(parser, context, 209008);
+      const forAwait = ((context & 4194304) > 0 || ((context & 2048) > 0 && (context & 8192) > 0)) &&
+          consumeOpt(parser, context, 209008);
       consume(parser, context | 32768, 67174411);
       if (scope)
           scope = addChildScope(scope, 1);
@@ -5554,7 +5592,7 @@
               if (parser.token & (143360 | 2097152)) {
                   if (parser.token === 8738868) {
                       if (context & 1024)
-                          report(parser, 64);
+                          report(parser, 65);
                   }
                   else {
                       init = finishNode(parser, context, tokenPos, linePos, colPos, {
@@ -5566,14 +5604,14 @@
                   parser.assignable = 1;
               }
               else if (context & 1024) {
-                  report(parser, 64);
+                  report(parser, 65);
               }
               else {
                   isVarDecl = false;
                   parser.assignable = 1;
                   init = parseMemberOrUpdateExpression(parser, context, init, 0, 0, tokenPos, linePos, colPos);
                   if (parser.token === 274549)
-                      report(parser, 111);
+                      report(parser, 112);
               }
           }
           else {
@@ -5594,7 +5632,7 @@
       }
       else if (token === 1074790417) {
           if (forAwait)
-              report(parser, 79);
+              report(parser, 80);
       }
       else if ((token & 2097152) === 2097152) {
           init =
@@ -5603,7 +5641,7 @@
                   : parseArrayExpressionOrPattern(parser, context, void 0, 1, 0, 0, 2, 32, tokenPos, linePos, colPos);
           destructible = parser.destructible;
           if (context & 256 && destructible & 64) {
-              report(parser, 60);
+              report(parser, 61);
           }
           parser.assignable =
               destructible & 16 ? 2 : 1;
@@ -5615,7 +5653,7 @@
       if ((parser.token & 262144) === 262144) {
           if (parser.token === 274549) {
               if (parser.assignable & 2)
-                  report(parser, 77, forAwait ? 'await' : 'of');
+                  report(parser, 78, forAwait ? 'await' : 'of');
               reinterpretToPattern(parser, init);
               nextToken(parser, context | 32768);
               right = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
@@ -5630,11 +5668,11 @@
               });
           }
           if (parser.assignable & 2)
-              report(parser, 77, 'in');
+              report(parser, 78, 'in');
           reinterpretToPattern(parser, init);
           nextToken(parser, context | 32768);
           if (forAwait)
-              report(parser, 79);
+              report(parser, 80);
           right = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
           consume(parser, context | 32768, 16);
           const body = parseIterationStatementBody(parser, context, scope, labels);
@@ -5646,10 +5684,10 @@
           });
       }
       if (forAwait)
-          report(parser, 79);
+          report(parser, 80);
       if (!isVarDecl) {
           if (destructible & 8 && parser.token !== 1077936157) {
-              report(parser, 77, 'loop');
+              report(parser, 78, 'loop');
           }
           init = parseAssignmentExpression(parser, context | 134217728, 0, 0, tokenPos, linePos, colPos, init);
       }
@@ -5673,9 +5711,9 @@
   }
   function parseRestrictedIdentifier(parser, context, scope) {
       if (!isValidIdentifier$1(context, parser.token))
-          report(parser, 114);
-      if ((parser.token & 537079808) === 537079808)
           report(parser, 115);
+      if ((parser.token & 537079808) === 537079808)
+          report(parser, 116);
       if (scope)
           addBlockName(parser, context, scope, parser.tokenValue, 8, 0);
       return parseIdentifier(parser, context, 0);
@@ -5709,7 +5747,7 @@
                           parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
                           break;
                       default:
-                          report(parser, 104);
+                          report(parser, 105);
                   }
               }
           }
@@ -5753,7 +5791,7 @@
   function parseModuleSpecifier(parser, context) {
       consumeOpt(parser, context, 12404);
       if (parser.token !== 134283267)
-          report(parser, 102, 'Import');
+          report(parser, 103, 'Import');
       return parseLiteral(parser, context);
   }
   function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
@@ -5764,7 +5802,7 @@
           let local;
           if (consumeOpt(parser, context, 77934)) {
               if ((parser.token & 134217728) === 134217728 || parser.token === 18) {
-                  report(parser, 103);
+                  report(parser, 104);
               }
               else {
                   validateBindingIdentifier(parser, context, 16, parser.token, 0);
@@ -5801,6 +5839,9 @@
   function parseImportCallDeclaration(parser, context, start, line, column) {
       let expr = parseImportExpression(parser, context, 0, start, line, column);
       expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+      if (parser.token === 18) {
+          expr = parseSequenceExpression(parser, context, 0, start, line, column, expr);
+      }
       return parseExpressionStatement(parser, context, expr, start, line, column);
   }
   function parseExportDeclaration(parser, context, scope) {
@@ -5826,7 +5867,7 @@
                   const { tokenPos, linePos, colPos } = parser;
                   declaration = parseIdentifier(parser, context, 0);
                   const { flags } = parser;
-                  if ((flags & 1) < 1) {
+                  if ((flags & 1) === 0) {
                       if (parser.token === 86106) {
                           declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 1, 1, tokenPos, linePos, colPos);
                       }
@@ -5868,7 +5909,7 @@
               }
               consume(parser, context, 12404);
               if (parser.token !== 134283267)
-                  report(parser, 102, 'Export');
+                  report(parser, 103, 'Export');
               source = parseLiteral(parser, context);
               matchOrInsertSemicolon(parser, context | 32768);
               return finishNode(parser, context, start, line, column, {
@@ -5888,7 +5929,7 @@
                   if (parser.token === 77934) {
                       nextToken(parser, context);
                       if ((parser.token & 134217728) === 134217728) {
-                          report(parser, 103);
+                          report(parser, 104);
                       }
                       if (scope) {
                           tmpExportedNames.push(parser.tokenValue);
@@ -5914,7 +5955,7 @@
               consume(parser, context, 1074790415);
               if (consumeOpt(parser, context, 12404)) {
                   if (parser.token !== 134283267)
-                      report(parser, 102, 'Export');
+                      report(parser, 103, 'Export');
                   source = parseLiteral(parser, context);
               }
               else if (scope) {
@@ -5950,7 +5991,7 @@
           case 209007:
               const { tokenPos, linePos, colPos } = parser;
               nextToken(parser, context);
-              if ((parser.flags & 1) < 1 && parser.token === 86106) {
+              if ((parser.flags & 1) === 0 && parser.token === 86106) {
                   declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 2, 1, tokenPos, linePos, colPos);
                   if (scope) {
                       key = declaration.id ? declaration.id.name : '';
@@ -6063,7 +6104,7 @@
           t = parser.token;
           prec = t & 3840;
           if ((t & 524288 && operator & 268435456) || (operator & 524288 && t & 268435456)) {
-              report(parser, 159);
+              report(parser, 160);
           }
           if (prec + ((t === 8457273) << 8) - ((bit === t) << 12) <= minPrec)
               break;
@@ -6089,10 +6130,10 @@
           report(parser, 31);
       if (context & 1024 && unaryOperator === 16863278) {
           if (arg.type === 'Identifier') {
-              report(parser, 117);
+              report(parser, 118);
           }
           else if (isPropertyWithPrivateFieldKey(arg)) {
-              report(parser, 123);
+              report(parser, 124);
           }
       }
       parser.assignable = 2;
@@ -6107,7 +6148,7 @@
       const { token } = parser;
       const expr = parseIdentifier(parser, context, isPattern);
       const { flags } = parser;
-      if ((flags & 1) < 1) {
+      if ((flags & 1) === 0) {
           if (parser.token === 86106) {
               return parseFunctionExpression(parser, context, 1, inGroup, start, line, column);
           }
@@ -6123,7 +6164,7 @@
       if (parser.token === 10) {
           classifyIdentifier(parser, context, token, 1);
           if (inNew)
-              report(parser, 48);
+              report(parser, 49);
           return parseArrowFromIdentifier(parser, context, parser.tokenValue, expr, inNew, canAssign, 0, start, line, column);
       }
       return expr;
@@ -6138,10 +6179,10 @@
           if (!canAssign)
               report(parser, 24);
           if (parser.token === 22)
-              report(parser, 120);
+              report(parser, 121);
           let argument = null;
           let delegate = false;
-          if ((parser.flags & 1) < 1) {
+          if ((parser.flags & 1) === 0) {
               delegate = consumeOpt(parser, context | 32768, 8457014);
               if (parser.token & (12288 | 65536) || delegate) {
                   argument = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
@@ -6155,7 +6196,7 @@
           });
       }
       if (context & 1024)
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       return parseIdentifierOrArrow(parser, context, start, line, column);
   }
   function parseAwaitExpression(parser, context, inNew, inGroup, start, line, column) {
@@ -6178,7 +6219,7 @@
           });
       }
       if (context & 2048)
-          report(parser, 95);
+          report(parser, 96);
       return parseIdentifierOrArrow(parser, context, start, line, column);
   }
   function parseFunctionBody(parser, context, scope, origin, firstRestricted, scopeError) {
@@ -6193,7 +6234,7 @@
               if (isValidStrictMode(parser, index, tokenPos, tokenValue)) {
                   context |= 1024;
                   if (parser.flags & 128) {
-                      reportMessageAt(parser.index, parser.line, parser.tokenPos, 63);
+                      reportMessageAt(parser.index, parser.line, parser.tokenPos, 64);
                   }
                   if (parser.flags & 64) {
                       reportMessageAt(parser.index, parser.line, parser.tokenPos, 8);
@@ -6204,22 +6245,22 @@
           if (context & 1024) {
               if (firstRestricted) {
                   if ((firstRestricted & 537079808) === 537079808) {
-                      report(parser, 115);
+                      report(parser, 116);
                   }
                   if ((firstRestricted & 36864) === 36864) {
                       report(parser, 38);
                   }
               }
               if (parser.flags & 512)
-                  report(parser, 115);
+                  report(parser, 116);
               if (parser.flags & 256)
-                  report(parser, 114);
+                  report(parser, 115);
           }
           if (context & 64 &&
               scope &&
               scopeError !== void 0 &&
-              (prevContext & 1024) < 1 &&
-              (context & 8192) < 1) {
+              (prevContext & 1024) === 0 &&
+              (context & 8192) === 0) {
               reportScopeError(scopeError);
           }
       }
@@ -6243,9 +6284,9 @@
       nextToken(parser, context);
       switch (parser.token) {
           case 67108991:
-              report(parser, 161);
+              report(parser, 162);
           case 67174411: {
-              if ((context & 524288) < 1)
+              if ((context & 524288) === 0)
                   report(parser, 26);
               if (context & 16384)
                   report(parser, 27);
@@ -6254,7 +6295,7 @@
           }
           case 69271571:
           case 67108877: {
-              if ((context & 262144) < 1)
+              if ((context & 262144) === 0)
                   report(parser, 27);
               if (context & 16384)
                   report(parser, 27);
@@ -6272,7 +6313,7 @@
   }
   function parseUpdateExpression(parser, context, expr, start, line, column) {
       if (parser.assignable & 2)
-          report(parser, 52);
+          report(parser, 53);
       const { token } = parser;
       nextToken(parser, context);
       parser.assignable = 2;
@@ -6284,7 +6325,7 @@
       });
   }
   function parseMemberOrUpdateExpression(parser, context, expr, inGroup, inChain, start, line, column) {
-      if ((parser.token & 33619968) === 33619968 && (parser.flags & 1) < 1) {
+      if ((parser.token & 33619968) === 33619968 && (parser.flags & 1) === 0) {
           expr = parseUpdateExpression(parser, context, expr, start, line, column);
       }
       else if ((parser.token & 67108864) === 67108864) {
@@ -6355,7 +6396,7 @@
               }
               default:
                   if ((parser.flags & 2048) === 2048) {
-                      report(parser, 160);
+                      report(parser, 161);
                   }
                   parser.assignable = 2;
                   expr = finishNode(parser, context, start, line, column, {
@@ -6411,8 +6452,8 @@
           });
       }
       else {
-          if ((parser.token & (143360 | 4096)) < 1)
-              report(parser, 154);
+          if ((parser.token & (143360 | 4096)) === 0)
+              report(parser, 155);
           const property = parseIdentifier(parser, context, 0);
           parser.assignable = 2;
           node = finishNode(parser, context, start, line, column, {
@@ -6429,8 +6470,8 @@
       return node;
   }
   function parsePropertyOrPrivatePropertyName(parser, context) {
-      if ((parser.token & (143360 | 4096)) < 1 && parser.token !== 131) {
-          report(parser, 154);
+      if ((parser.token & (143360 | 4096)) === 0 && parser.token !== 131) {
+          report(parser, 155);
       }
       return context & 1 && parser.token === 131
           ? parsePrivateIdentifier(parser, context, parser.tokenPos, parser.linePos, parser.colPos)
@@ -6438,14 +6479,14 @@
   }
   function parseUpdateExpressionPrefixed(parser, context, inNew, isLHS, start, line, column) {
       if (inNew)
-          report(parser, 53);
+          report(parser, 54);
       if (!isLHS)
           report(parser, 0);
       const { token } = parser;
       nextToken(parser, context | 32768);
       const arg = parseLeftHandSideExpression(parser, context, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
       if (parser.assignable & 2) {
-          report(parser, 52);
+          report(parser, 53);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -6474,12 +6515,12 @@
               return parseArrowFromIdentifier(parser, context, tokenValue, expr, inNew, canAssign, 0, start, line, column);
           }
           if (context & 16384 && token === 537079928)
-              report(parser, 126);
+              report(parser, 127);
           if (token === 241739) {
               if (context & 1024)
-                  report(parser, 109);
+                  report(parser, 110);
               if (kind & (8 | 16))
-                  report(parser, 97);
+                  report(parser, 98);
           }
           parser.assignable =
               context & 1024 && (token & 537079808) === 537079808
@@ -6550,14 +6591,14 @@
           return parseImportMetaExpression(parser, context, expr, start, line, column);
       }
       if (inNew)
-          report(parser, 137);
+          report(parser, 138);
       expr = parseImportExpression(parser, context, inGroup, start, line, column);
       parser.assignable = 2;
       return parseMemberOrUpdateExpression(parser, context, expr, inGroup, 0, start, line, column);
   }
   function parseImportMetaExpression(parser, context, meta, start, line, column) {
       if ((context & 2048) === 0)
-          report(parser, 163);
+          report(parser, 164);
       nextToken(parser, context);
       if (parser.token !== 143495 && parser.tokenValue !== 'meta')
           report(parser, 28, KeywordDescTable[parser.token & 255]);
@@ -6571,7 +6612,7 @@
   function parseImportExpression(parser, context, inGroup, start, line, column) {
       consume(parser, context | 32768, 67174411);
       if (parser.token === 14)
-          report(parser, 138);
+          report(parser, 139);
       const source = parseExpression(parser, context, 1, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
       consume(parser, context, 16);
       return finishNode(parser, context, start, line, column, {
@@ -6616,14 +6657,14 @@
       ];
       const expressions = [parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos)];
       if (parser.token !== 1074790415)
-          report(parser, 80);
+          report(parser, 81);
       while ((parser.token = scanTemplateTail(parser, context)) !== 67174409) {
           const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
           consume(parser, context | 32768, 67174408);
           quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenPos, linePos, colPos, false));
           expressions.push(parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos));
           if (parser.token !== 1074790415)
-              report(parser, 80);
+              report(parser, 81);
       }
       {
           const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
@@ -6754,11 +6795,11 @@
       let firstRestricted;
       let functionScope = scope ? createScope() : void 0;
       if (parser.token === 67174411) {
-          if ((flags & 1) < 1)
+          if ((flags & 1) === 0)
               report(parser, 37, 'Function');
       }
       else {
-          const kind = origin & 4 && ((context & 8192) < 1 || (context & 2048) < 1)
+          const kind = origin & 4 && ((context & 8192) === 0 || (context & 2048) === 0)
               ? 4
               : 64;
           validateFunctionName(parser, context | ((context & 3072) << 11), parser.token);
@@ -6839,10 +6880,10 @@
   function parseArrayLiteral(parser, context, skipInitializer, inGroup, start, line, column) {
       const expr = parseArrayExpressionOrPattern(parser, context, void 0, skipInitializer, inGroup, 0, 2, 0, start, line, column);
       if (context & 256 && parser.destructible & 64) {
-          report(parser, 60);
+          report(parser, 61);
       }
       if (parser.destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       return expr;
   }
@@ -6904,7 +6945,7 @@
                       destructible |=
                           kind & 1
                               ? 32
-                              : (kind & 2) < 1
+                              : (kind & 2) === 0
                                   ? 16
                                   : 0;
                       left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
@@ -6937,7 +6978,7 @@
                       }
                   }
                   else if (parser.destructible & 8) {
-                      report(parser, 68);
+                      report(parser, 69);
                   }
                   else {
                       left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
@@ -6963,7 +7004,7 @@
                   left = parseLeftHandSideExpression(parser, context, 1, 0, 1, tokenPos, linePos, colPos);
                   if (parser.token !== 18 && parser.token !== 20) {
                       left = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, left);
-                      if ((kind & (2 | 1)) < 1 && token === 67174411)
+                      if ((kind & (2 | 1)) === 0 && token === 67174411)
                           destructible |= 16;
                   }
                   else if (parser.assignable & 2) {
@@ -7036,7 +7077,7 @@
           argument = parseMemberOrUpdateExpression(parser, context, argument, inGroup, 0, tokenPos, linePos, colPos);
           if (parser.token !== 18 && parser.token !== closingToken) {
               if (parser.assignable & 2 && parser.token === 1077936157)
-                  report(parser, 68);
+                  report(parser, 69);
               destructible |= 16;
               argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
           }
@@ -7063,7 +7104,7 @@
           token = parser.token;
           if (token !== 1077936157 && token !== closingToken && token !== 18) {
               if (parser.destructible & 8)
-                  report(parser, 68);
+                  report(parser, 69);
               argument = parseMemberOrUpdateExpression(parser, context, argument, inGroup, 0, tokenPos, linePos, colPos);
               destructible |= parser.assignable & 2 ? 16 : 0;
               if ((parser.token & 4194304) === 4194304) {
@@ -7113,7 +7154,7 @@
           }
           parser.destructible = destructible;
           if (parser.token !== closingToken && parser.token !== 18)
-              report(parser, 155);
+              report(parser, 156);
           return finishNode(parser, context, start, line, column, {
               type: isPattern ? 'RestElement' : 'SpreadElement',
               argument: argument
@@ -7152,7 +7193,7 @@
       });
   }
   function parseMethodDefinition(parser, context, kind, inGroup, start, line, column) {
-      const modifierFlags = (kind & 64) < 1 ? 31981568 : 14680064;
+      const modifierFlags = (kind & 64) === 0 ? 31981568 : 14680064;
       context =
           ((context | modifierFlags) ^ modifierFlags) |
               ((kind & 88) << 18) |
@@ -7174,10 +7215,10 @@
   function parseObjectLiteral(parser, context, skipInitializer, inGroup, start, line, column) {
       const expr = parseObjectLiteralOrPattern(parser, context, void 0, skipInitializer, inGroup, 0, 2, 0, start, line, column);
       if (context & 256 && parser.destructible & 64) {
-          report(parser, 60);
+          report(parser, 61);
       }
       if (parser.destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       return expr;
   }
@@ -7294,7 +7335,7 @@
                                   destructible |= 16;
                           }
                           else if (parser.destructible & 8) {
-                              report(parser, 68);
+                              report(parser, 69);
                           }
                           else {
                               value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7354,10 +7395,10 @@
                   else if (parser.token & (143360 | 4096)) {
                       destructible |= 16;
                       if (token === 121)
-                          report(parser, 92);
+                          report(parser, 93);
                       if (token === 209007) {
                           if (parser.flags & 1)
-                              report(parser, 128);
+                              report(parser, 129);
                           state |= 16;
                       }
                       key = parseIdentifier(parser, context, 0);
@@ -7376,11 +7417,14 @@
                   }
                   else if (parser.token === 8457014) {
                       destructible |= 16;
-                      if (token === 12402 || token === 12403) {
+                      if (token === 12402) {
                           report(parser, 40);
                       }
+                      else if (token === 12403) {
+                          report(parser, 41);
+                      }
                       else if (token === 143483) {
-                          report(parser, 92);
+                          report(parser, 93);
                       }
                       nextToken(parser, context);
                       state |=
@@ -7415,7 +7459,7 @@
                       value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                   }
                   else {
-                      report(parser, 129);
+                      report(parser, 130);
                   }
               }
               else if ((parser.token & 134217728) === 134217728) {
@@ -7516,7 +7560,7 @@
                       destructible = parser.assignable | 16;
                   }
                   else {
-                      report(parser, 130);
+                      report(parser, 131);
                   }
               }
               else if (parser.token === 69271571) {
@@ -7573,7 +7617,7 @@
                                   destructible |= 16;
                           }
                           else if (destructible & 8) {
-                              report(parser, 59);
+                              report(parser, 60);
                           }
                           else {
                               value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7625,7 +7669,7 @@
                       destructible = 16;
                   }
                   else {
-                      report(parser, 41);
+                      report(parser, 42);
                   }
               }
               else if (token === 8457014) {
@@ -7641,10 +7685,10 @@
                       }
                       else {
                           reportMessageAt(index, line, index, token === 209007
-                              ? 43
+                              ? 44
                               : token === 12402 || parser.token === 12403
-                                  ? 42
-                                  : 44, KeywordDescTable[token & 255]);
+                                  ? 43
+                                  : 45, KeywordDescTable[token & 255]);
                       }
                   }
                   else if ((parser.token & 134217728) === 134217728) {
@@ -7660,7 +7704,7 @@
                       value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                   }
                   else {
-                      report(parser, 122);
+                      report(parser, 123);
                   }
               }
               else {
@@ -7720,7 +7764,7 @@
           let left = null;
           const { tokenPos, linePos, colPos } = parser;
           if (parser.token & 143360) {
-              if ((context & 1024) < 1) {
+              if ((context & 1024) === 0) {
                   if ((parser.token & 36864) === 36864) {
                       parser.flags |= 256;
                   }
@@ -7742,7 +7786,7 @@
               }
               isSimpleParameterList = 1;
               if (parser.destructible & (32 | 16))
-                  report(parser, 47);
+                  report(parser, 48);
           }
           if (parser.token === 1077936157) {
               nextToken(parser, context | 32768);
@@ -7834,7 +7878,7 @@
               parser.assignable = 2;
               if (parser.token !== 16 && parser.token !== 18) {
                   if (destructible & 8)
-                      report(parser, 118);
+                      report(parser, 119);
                   expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
                   destructible |= 16;
                   if (parser.token !== 16 && parser.token !== 18) {
@@ -7845,7 +7889,7 @@
           else if (token === 14) {
               expr = parseSpreadOrRestElement(parser, context, scope, 16, kind, origin, 0, 1, 0, tokenPos, linePos, colPos);
               if (parser.destructible & 16)
-                  report(parser, 71);
+                  report(parser, 72);
               isSimpleParameterList = 1;
               if (isSequence && (parser.token === 16 || parser.token === 18)) {
                   expressions.push(expr);
@@ -7902,7 +7946,7 @@
       }
       consume(parser, context, 16);
       if (destructible & 16 && destructible & 8)
-          report(parser, 145);
+          report(parser, 146);
       destructible |=
           parser.destructible & 256
               ? 256
@@ -7911,7 +7955,7 @@
                   : 0;
       if (parser.token === 10) {
           if (destructible & (32 | 16))
-              report(parser, 46);
+              report(parser, 47);
           if (context & (4194304 | 2048) && destructible & 128)
               report(parser, 29);
           if (context & (1024 | 2097152) && destructible & 256) {
@@ -7922,7 +7966,7 @@
           return parseParenthesizedArrow(parser, context, scope, isSequence ? expressions : [expr], canAssign, 0, start, line, column);
       }
       else if (destructible & 8) {
-          report(parser, 139);
+          report(parser, 140);
       }
       parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
       return context & 128
@@ -7947,23 +7991,23 @@
   }
   function parseArrowFromIdentifier(parser, context, value, expr, inNew, canAssign, isAsync, start, line, column) {
       if (!canAssign)
-          report(parser, 54);
+          report(parser, 55);
       if (inNew)
-          report(parser, 48);
+          report(parser, 49);
       parser.flags &= ~128;
       const scope = context & 64 ? createArrowHeadParsingScope(parser, context, value) : void 0;
       return parseArrowFunctionExpression(parser, context, scope, [expr], isAsync, start, line, column);
   }
   function parseParenthesizedArrow(parser, context, scope, params, canAssign, isAsync, start, line, column) {
       if (!canAssign)
-          report(parser, 54);
+          report(parser, 55);
       for (let i = 0; i < params.length; ++i)
           reinterpretToPattern(parser, params[i]);
       return parseArrowFunctionExpression(parser, context, scope, params, isAsync, start, line, column);
   }
   function parseArrowFunctionExpression(parser, context, scope, params, isAsync, start, line, column) {
       if (parser.flags & 1)
-          report(parser, 45);
+          report(parser, 46);
       consume(parser, context | 32768, 10);
       context = ((context | 15728640) ^ 15728640) | (isAsync << 22);
       const expression = parser.token !== 2162700;
@@ -7981,25 +8025,25 @@
               (134221824 | 8192 | 16384), scope, 16, void 0, void 0);
           switch (parser.token) {
               case 69271571:
-                  if ((parser.flags & 1) < 1) {
-                      report(parser, 112);
+                  if ((parser.flags & 1) === 0) {
+                      report(parser, 113);
                   }
                   break;
               case 67108877:
               case 67174409:
               case 22:
-                  report(parser, 113);
+                  report(parser, 114);
               case 67174411:
-                  if ((parser.flags & 1) < 1) {
-                      report(parser, 112);
+                  if ((parser.flags & 1) === 0) {
+                      report(parser, 113);
                   }
                   parser.flags |= 1024;
                   break;
           }
-          if ((parser.token & 8454144) === 8454144 && (parser.flags & 1) < 1)
+          if ((parser.token & 8454144) === 8454144 && (parser.flags & 1) === 0)
               report(parser, 28, KeywordDescTable[parser.token & 255]);
           if ((parser.token & 33619968) === 33619968)
-              report(parser, 121);
+              report(parser, 122);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -8022,7 +8066,7 @@
           let left;
           const { tokenPos, linePos, colPos } = parser;
           if (parser.token & 143360) {
-              if ((context & 1024) < 1) {
+              if ((context & 1024) === 0) {
                   if ((parser.token & 36864) === 36864) {
                       parser.flags |= 256;
                   }
@@ -8047,7 +8091,7 @@
               }
               isSimpleParameterList = 1;
               if (parser.destructible & (32 | 16)) {
-                  report(parser, 47);
+                  report(parser, 48);
               }
           }
           if (parser.token === 1077936157) {
@@ -8123,16 +8167,16 @@
               parser.assignable = 2;
               return parseMetaProperty(parser, context, id, start, line, column);
           }
-          report(parser, 91);
+          report(parser, 92);
       }
       parser.assignable = 2;
       if ((parser.token & 16842752) === 16842752) {
-          report(parser, 62, KeywordDescTable[parser.token & 255]);
+          report(parser, 63, KeywordDescTable[parser.token & 255]);
       }
       const expr = parsePrimaryExpression(parser, context, 2, 1, 0, 0, inGroup, 1, tokenPos, linePos, colPos);
       context = (context | 134217728) ^ 134217728;
       if (parser.token === 67108991)
-          report(parser, 162);
+          report(parser, 163);
       const callee = parseMembeExpressionNoCall(parser, context, expr, inGroup, tokenPos, linePos, colPos);
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -8167,7 +8211,7 @@
       if (consumeOpt(parser, context, 16)) {
           if (parser.token === 10) {
               if (flags & 1)
-                  report(parser, 45);
+                  report(parser, 46);
               return parseParenthesizedArrow(parser, context, scope, [], canAssign, 1, start, line, column);
           }
           return finishNode(parser, context, start, line, column, {
@@ -8223,7 +8267,7 @@
               isSimpleParameterList = 1;
               if (parser.token !== 16 && parser.token !== 18) {
                   if (destructible & 8)
-                      report(parser, 118);
+                      report(parser, 119);
                   expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
                   destructible |= 16;
                   if ((parser.token & 8454144) === 8454144) {
@@ -8271,7 +8315,7 @@
           if (destructible & (32 | 16))
               report(parser, 25);
           if (parser.flags & 1 || flags & 1)
-              report(parser, 45);
+              report(parser, 46);
           if (destructible & 128)
               report(parser, 29);
           if (context & (1024 | 2097152) && destructible & 256)
@@ -8281,7 +8325,7 @@
           return parseParenthesizedArrow(parser, context, scope, params, canAssign, 1, start, line, column);
       }
       else if (destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -8326,10 +8370,10 @@
       const { tokenValue } = parser;
       if (parser.token & 4096 && parser.token !== 20567) {
           if (isStrictReservedWord$1(parser, context, parser.token)) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if ((parser.token & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
           if (scope) {
               addBlockName(parser, context, scope, tokenValue, 32, 0);
@@ -8342,7 +8386,7 @@
           id = parseIdentifier(parser, context, 0);
       }
       else {
-          if ((flags & 1) < 1)
+          if ((flags & 1) === 0)
               report(parser, 37, 'Class');
       }
       let inheritedContext = context;
@@ -8382,9 +8426,9 @@
       nextToken(parser, context);
       if (parser.token & 4096 && parser.token !== 20567) {
           if (isStrictReservedWord$1(parser, context, parser.token))
-              report(parser, 114);
-          if ((parser.token & 537079808) === 537079808) {
               report(parser, 115);
+          if ((parser.token & 537079808) === 537079808) {
+              report(parser, 116);
           }
           id = parseIdentifier(parser, context, 0);
       }
@@ -8443,13 +8487,13 @@
           decorators = parseDecorators(parser, context);
           length = decorators.length;
           if (length > 0 && parser.tokenValue === 'constructor') {
-              report(parser, 106);
+              report(parser, 107);
           }
           if (parser.token === 1074790415)
-              report(parser, 105);
+              report(parser, 106);
           if (consumeOpt(parser, context, 1074790417)) {
               if (length > 0)
-                  report(parser, 116);
+                  report(parser, 117);
               continue;
           }
           body.push(parseClassElementList(parser, context, scope, inheritedContext, kind, decorators, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos));
@@ -8468,12 +8512,15 @@
           key = parseIdentifier(parser, context, 0);
           switch (token) {
               case 36972:
-                  if (!isStatic && parser.token !== 67174411) {
+                  if (!isStatic &&
+                      parser.token !== 67174411 &&
+                      (parser.token & 1048576) !== 1048576 &&
+                      parser.token !== 1077936157) {
                       return parseClassElementList(parser, context, scope, inheritedContext, type, decorators, 1, inGroup, start, line, column);
                   }
                   break;
               case 209007:
-                  if (parser.token !== 67174411 && (parser.flags & 1) < 1) {
+                  if (parser.token !== 67174411 && (parser.flags & 1) === 0) {
                       if (context & 1 && (parser.token & 1073741824) === 1073741824) {
                           return parsePropertyDefinition(parser, context, key, kind, decorators, tokenPos, linePos, colPos);
                       }
@@ -8516,6 +8563,9 @@
       else if (context & 1 && (parser.token & 1073741824) === 1073741824) {
           kind |= 128;
       }
+      else if (isStatic && token === 2162700) {
+          return parseStaticBlock(parser, context, scope, tokenPos, linePos, colPos);
+      }
       else if (token === 122) {
           key = parseIdentifier(parser, context, 0);
           if (parser.token !== 67174411)
@@ -8543,30 +8593,30 @@
               key = parsePrivateIdentifier(parser, context, tokenPos, linePos, colPos);
           }
           else
-              report(parser, 131);
+              report(parser, 132);
       }
-      if ((kind & 2) < 1) {
+      if ((kind & 2) === 0) {
           if (parser.tokenValue === 'constructor') {
               if ((parser.token & 1073741824) === 1073741824) {
-                  report(parser, 125);
+                  report(parser, 126);
               }
-              else if ((kind & 32) < 1 && parser.token === 67174411) {
+              else if ((kind & 32) === 0 && parser.token === 67174411) {
                   if (kind & (768 | 16 | 128 | 8)) {
-                      report(parser, 50, 'accessor');
+                      report(parser, 51, 'accessor');
                   }
-                  else if ((context & 524288) < 1) {
+                  else if ((context & 524288) === 0) {
                       if (parser.flags & 32)
-                          report(parser, 51);
+                          report(parser, 52);
                       else
                           parser.flags |= 32;
                   }
               }
               kind |= 64;
           }
-          else if ((kind & 4096) < 1 &&
+          else if ((kind & 4096) === 0 &&
               kind & (32 | 768 | 8 | 16) &&
               parser.tokenValue === 'prototype') {
-              report(parser, 49);
+              report(parser, 50);
           }
       }
       if (context & 1 && parser.token !== 67174411) {
@@ -8576,7 +8626,7 @@
       return finishNode(parser, context, start, line, column, context & 1
           ? {
               type: 'MethodDefinition',
-              kind: (kind & 32) < 1 && kind & 64
+              kind: (kind & 32) === 0 && kind & 64
                   ? 'constructor'
                   : kind & 256
                       ? 'get'
@@ -8591,7 +8641,7 @@
           }
           : {
               type: 'MethodDefinition',
-              kind: (kind & 32) < 1 && kind & 64
+              kind: (kind & 32) === 0 && kind & 64
                   ? 'constructor'
                   : kind & 256
                       ? 'get'
@@ -8608,7 +8658,7 @@
       nextToken(parser, context);
       const { tokenValue } = parser;
       if (tokenValue === 'constructor')
-          report(parser, 124);
+          report(parser, 125);
       nextToken(parser, context);
       return finishNode(parser, context, start, line, column, {
           type: 'PrivateIdentifier',
@@ -8623,7 +8673,7 @@
           nextToken(parser, context | 32768);
           const { tokenPos, linePos, colPos } = parser;
           if (parser.token === 537079928)
-              report(parser, 115);
+              report(parser, 116);
           value = parsePrimaryExpression(parser, context | 16384, 2, 0, 1, 0, 0, 1, tokenPos, linePos, colPos);
           if ((parser.token & 1073741824) !== 1073741824) {
               value = parseMemberOrUpdateExpression(parser, context | 16384, value, 0, 0, tokenPos, linePos, colPos);
@@ -8651,33 +8701,33 @@
           ? parseArrayExpressionOrPattern(parser, context, scope, 1, 0, 1, type, origin, start, line, column)
           : parseObjectLiteralOrPattern(parser, context, scope, 1, 0, 1, type, origin, start, line, column);
       if (parser.destructible & 16)
-          report(parser, 47);
+          report(parser, 48);
       if (parser.destructible & 32)
-          report(parser, 47);
+          report(parser, 48);
       return left;
   }
   function parseAndClassifyIdentifier(parser, context, scope, kind, origin, start, line, column) {
       const { tokenValue, token } = parser;
       if (context & 1024) {
           if ((token & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
           else if ((token & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
       }
       if ((token & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (context & (2048 | 2097152) && token === 241773) {
           report(parser, 30);
       }
       if (token === 241739) {
           if (kind & (8 | 16))
-              report(parser, 97);
+              report(parser, 98);
       }
       if (context & (4194304 | 2048) && token === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       nextToken(parser, context);
       if (scope)
@@ -8705,7 +8755,7 @@
           closingElement = parseJSXClosingElement(parser, context, inJSXChild, parser.tokenPos, parser.linePos, parser.colPos);
           const close = isEqualTagName(closingElement.name);
           if (isEqualTagName(openingElement.name) !== close)
-              report(parser, 149, close);
+              report(parser, 150, close);
       }
       return finishNode(parser, context, start, line, column, {
           type: 'JSXElement',
@@ -8861,7 +8911,7 @@
                   value = parseJSXExpressionContainer(parser, context, 1, 1, tokenPos, linePos, colPos);
                   break;
               default:
-                  report(parser, 148);
+                  report(parser, 149);
           }
       }
       return finishNode(parser, context, start, line, column, {
@@ -8883,11 +8933,11 @@
       nextToken(parser, context | 32768);
       const { tokenPos, linePos, colPos } = parser;
       if (parser.token === 14)
-          return parseJSXSpreadChild(parser, context, tokenPos, linePos, colPos);
+          return parseJSXSpreadChild(parser, context, start, line, column);
       let expression = null;
       if (parser.token === 1074790415) {
           if (isAttr)
-              report(parser, 151);
+              report(parser, 152);
           expression = parseJSXEmptyExpression(parser, context, parser.startPos, parser.startLine, parser.startColumn);
       }
       else {
@@ -9760,12 +9810,22 @@
       if (node.static) {
         state.write('static ');
       }
+      if (node.computed) {
+        state.write('[');
+      }
       this[node.key.type](node.key, state);
+      if (node.computed) {
+        state.write(']');
+      }
       if (node.value == null) {
+        if (node.key.type[0] !== 'F') {
+          state.write(';');
+        }
         return
       }
       state.write(' = ');
       this[node.value.type](node.value, state);
+      state.write(';');
     },
     ObjectPattern(node, state) {
       state.write('{');
@@ -10101,10 +10161,21 @@
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+  }
+
   function getAugmentedNamespace(n) {
+    if (n.__esModule) return n;
     var f = n.default;
   	if (typeof f == "function") {
-  		var a = function () {
+  		var a = function a () {
+  			if (this instanceof a) {
+  				var args = [null];
+  				args.push.apply(args, arguments);
+  				var Ctor = Function.bind.apply(f, args);
+  				return new Ctor();
+  			}
   			return f.apply(this, arguments);
   		};
   		a.prototype = f.prototype;
@@ -10585,7 +10656,7 @@
 
   	exports.Function = convertCallbackFunction;
 
-  	exports.VoidFunction = convertCallbackFunction;
+  	exports.VoidFunction = convertCallbackFunction; 
   } (lib));
 
   var utils = {exports: {}};
@@ -10716,9 +10787,11 @@
   	  namedSetNew,
   	  namedSetExisting,
   	  namedDelete
-  	};
+  	}; 
   } (utils));
 
+  var utilsExports = utils.exports;
+
   var URLImpl = {};
 
   var urlStateMachine = {exports: {}};
@@ -10738,7 +10811,7 @@
 
   /** Regular expressions */
   const regexPunycode = /^xn--/;
-  const regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars
+  const regexNonASCII = /[^\0-\x7F]/; // Note: U+007F DEL is excluded too.
   const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
 
   /** Error messages */
@@ -10773,11 +10846,11 @@
    * item.
    * @returns {Array} A new array of values returned by the callback function.
    */
-  function map(array, fn) {
+  function map(array, callback) {
   	const result = [];
   	let length = array.length;
   	while (length--) {
-  		result[length] = fn(array[length]);
+  		result[length] = callback(array[length]);
   	}
   	return result;
   }
@@ -10789,22 +10862,22 @@
    * @param {String} domain The domain name or email address.
    * @param {Function} callback The function that gets called for every
    * character.
-   * @returns {Array} A new string of characters returned by the callback
+   * @returns {String} A new string of characters returned by the callback
    * function.
    */
-  function mapDomain(string, fn) {
-  	const parts = string.split('@');
+  function mapDomain(domain, callback) {
+  	const parts = domain.split('@');
   	let result = '';
   	if (parts.length > 1) {
   		// In email addresses, only the domain name should be punycoded. Leave
   		// the local part (i.e. everything up to `@`) intact.
   		result = parts[0] + '@';
-  		string = parts[1];
+  		domain = parts[1];
   	}
   	// Avoid `split(regex)` for IE8 compatibility. See #17.
-  	string = string.replace(regexSeparators, '\x2E');
-  	const labels = string.split('.');
-  	const encoded = map(labels, fn).join('.');
+  	domain = domain.replace(regexSeparators, '\x2E');
+  	const labels = domain.split('.');
+  	const encoded = map(labels, callback).join('.');
   	return result + encoded;
   }
 
@@ -10853,7 +10926,7 @@
    * @param {Array} codePoints The array of numeric code points.
    * @returns {String} The new Unicode string (UCS-2).
    */
-  const ucs2encode = array => String.fromCodePoint(...array);
+  const ucs2encode = codePoints => String.fromCodePoint(...codePoints);
 
   /**
    * Converts a basic code point into a digit/integer.
@@ -10865,13 +10938,13 @@
    * the code point does not represent a value.
    */
   const basicToDigit = function(codePoint) {
-  	if (codePoint - 0x30 < 0x0A) {
-  		return codePoint - 0x16;
+  	if (codePoint >= 0x30 && codePoint < 0x3A) {
+  		return 26 + (codePoint - 0x30);
   	}
-  	if (codePoint - 0x41 < 0x1A) {
+  	if (codePoint >= 0x41 && codePoint < 0x5B) {
   		return codePoint - 0x41;
   	}
-  	if (codePoint - 0x61 < 0x1A) {
+  	if (codePoint >= 0x61 && codePoint < 0x7B) {
   		return codePoint - 0x61;
   	}
   	return base;
@@ -10951,7 +11024,7 @@
   		// which gets added to `i`. The overflow checking is easier
   		// if we increase `i` as we go, then subtract off its starting
   		// value at the end to obtain `delta`.
-  		let oldi = i;
+  		const oldi = i;
   		for (let w = 1, k = base; /* no condition */; k += base) {
 
   			if (index >= inputLength) {
@@ -10960,7 +11033,10 @@
 
   			const digit = basicToDigit(input.charCodeAt(index++));
 
-  			if (digit >= base || digit > floor((maxInt - i) / w)) {
+  			if (digit >= base) {
+  				error('invalid-input');
+  			}
+  			if (digit > floor((maxInt - i) / w)) {
   				error('overflow');
   			}
 
@@ -11014,7 +11090,7 @@
   	input = ucs2decode(input);
 
   	// Cache the length.
-  	let inputLength = input.length;
+  	const inputLength = input.length;
 
   	// Initialize the state.
   	let n = initialN;
@@ -11028,7 +11104,7 @@
   		}
   	}
 
-  	let basicLength = output.length;
+  	const basicLength = output.length;
   	let handledCPCount = basicLength;
 
   	// `handledCPCount` is the number of code points that have been handled;
@@ -11065,7 +11141,7 @@
   			if (currentValue < n && ++delta > maxInt) {
   				error('overflow');
   			}
-  			if (currentValue == n) {
+  			if (currentValue === n) {
   				// Represent delta as a generalized variable-length integer.
   				let q = delta;
   				for (let k = base; /* no condition */; k += base) {
@@ -11082,7 +11158,7 @@
   				}
 
   				output.push(stringFromCharCode(digitToBasic(q, 0)));
-  				bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+  				bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
   				delta = 0;
   				++handledCPCount;
   			}
@@ -11162,13 +11238,13 @@
 
   var punycode_es6 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ucs2decode: ucs2decode,
-    ucs2encode: ucs2encode,
     decode: decode,
+    default: punycode$1,
     encode: encode,
     toASCII: toASCII$1,
     toUnicode: toUnicode$1,
-    'default': punycode$1
+    ucs2decode: ucs2decode,
+    ucs2encode: ucs2encode
   });
 
   var require$$0 = /*@__PURE__*/getAugmentedNamespace(punycode_es6);
@@ -78609,9 +78685,11 @@
 
   	  // We don't handle blobs, so this just delegates:
   	  return module.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride });
-  	};
+  	}; 
   } (urlStateMachine));
 
+  var urlStateMachineExports = urlStateMachine.exports;
+
   var URLSearchParams = {exports: {}};
 
   var URLSearchParamsImpl = {};
@@ -78626,6 +78704,7 @@
    * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    */
+  lodash_sortby.exports;
 
   var hasRequiredLodash_sortby;
 
@@ -81253,8 +81332,8 @@
   		  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
   		}
 
-  		module.exports = sortBy;
-  } (lodash_sortby, lodash_sortby.exports));
+  		module.exports = sortBy; 
+  	} (lodash_sortby, lodash_sortby.exports));
   	return lodash_sortby.exports;
   }
 
@@ -81390,14 +81469,14 @@
   (function (module) {
 
   	const conversions = lib;
-  	const utils$1 = utils.exports;
+  	const utils = utilsExports;
 
-  	const impl = utils$1.implSymbol;
+  	const impl = utils.implSymbol;
 
-  	const IteratorPrototype = Object.create(utils$1.IteratorPrototype, {
+  	const IteratorPrototype = Object.create(utils.IteratorPrototype, {
   	  next: {
   	    value: function next() {
-  	      const internal = this[utils$1.iterInternalSymbol];
+  	      const internal = this[utils.iterInternalSymbol];
   	      const { target, kind, index } = internal;
   	      const values = Array.from(target[impl]);
   	      const len = values.length;
@@ -81407,7 +81486,7 @@
 
   	      const pair = values[index];
   	      internal.index = index + 1;
-  	      const [key, value] = pair.map(utils$1.tryWrapperForImpl);
+  	      const [key, value] = pair.map(utils.tryWrapperForImpl);
 
   	      let result;
   	      switch (kind) {
@@ -81438,9 +81517,9 @@
   	    {
   	      let curArg = arguments[0];
   	      if (curArg !== undefined) {
-  	        if (utils$1.isObject(curArg)) {
+  	        if (utils.isObject(curArg)) {
   	          if (curArg[Symbol.iterator] !== undefined) {
-  	            if (!utils$1.isObject(curArg)) {
+  	            if (!utils.isObject(curArg)) {
   	              throw new TypeError(
   	                "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."
   	              );
@@ -81448,7 +81527,7 @@
   	              const V = [];
   	              const tmp = curArg;
   	              for (let nextItem of tmp) {
-  	                if (!utils$1.isObject(nextItem)) {
+  	                if (!utils.isObject(nextItem)) {
   	                  throw new TypeError(
   	                    "Failed to construct 'URLSearchParams': parameter 1" +
   	                      " sequence" +
@@ -81474,7 +81553,7 @@
   	              curArg = V;
   	            }
   	          } else {
-  	            if (!utils$1.isObject(curArg)) {
+  	            if (!utils.isObject(curArg)) {
   	              throw new TypeError(
   	                "Failed to construct 'URLSearchParams': parameter 1" + " record" + " is not an object."
   	              );
@@ -81605,7 +81684,7 @@
   	      });
   	      args.push(curArg);
   	    }
-  	    return utils$1.tryWrapperForImpl(this[impl].getAll(...args));
+  	    return utils.tryWrapperForImpl(this[impl].getAll(...args));
   	  }
 
   	  has(name) {
@@ -81710,7 +81789,7 @@
   	    let pairs = Array.from(this[impl]);
   	    let i = 0;
   	    while (i < pairs.length) {
-  	      const [key, value] = pairs[i].map(utils$1.tryWrapperForImpl);
+  	      const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
   	      callback.call(thisArg, value, key, this);
   	      pairs = Array.from(this[impl]);
   	      i++;
@@ -81740,7 +81819,7 @@
   	  _mixedIntoPredicates: [],
   	  is(obj) {
   	    if (obj) {
-  	      if (utils$1.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+  	      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
   	        return true;
   	      }
   	      for (const isMixedInto of module.exports._mixedIntoPredicates) {
@@ -81757,7 +81836,7 @@
   	        return true;
   	      }
 
-  	      const wrapper = utils$1.wrapperForImpl(obj);
+  	      const wrapper = utils.wrapperForImpl(obj);
   	      for (const isMixedInto of module.exports._mixedIntoPredicates) {
   	        if (isMixedInto(wrapper)) {
   	          return true;
@@ -81768,14 +81847,14 @@
   	  },
   	  convert(obj, { context = "The provided value" } = {}) {
   	    if (module.exports.is(obj)) {
-  	      return utils$1.implForWrapper(obj);
+  	      return utils.implForWrapper(obj);
   	    }
   	    throw new TypeError(`${context} is not of type 'URLSearchParams'.`);
   	  },
 
   	  createDefaultIterator(target, kind) {
   	    const iterator = Object.create(IteratorPrototype);
-  	    Object.defineProperty(iterator, utils$1.iterInternalSymbol, {
+  	    Object.defineProperty(iterator, utils.iterInternalSymbol, {
   	      value: { target, kind, index: 0 },
   	      configurable: true
   	    });
@@ -81790,7 +81869,7 @@
   	  createImpl(constructorArgs, privateData) {
   	    let obj = Object.create(URLSearchParams.prototype);
   	    obj = this.setup(obj, constructorArgs, privateData);
-  	    return utils$1.implForWrapper(obj);
+  	    return utils.implForWrapper(obj);
   	  },
   	  _internalSetup(obj) {},
   	  setup(obj, constructorArgs, privateData) {
@@ -81804,7 +81883,7 @@
   	      configurable: true
   	    });
 
-  	    obj[impl][utils$1.wrapperSymbol] = obj;
+  	    obj[impl][utils.wrapperSymbol] = obj;
   	    if (Impl.init) {
   	      Impl.init(obj[impl], privateData);
   	    }
@@ -81818,17 +81897,19 @@
   	}; // iface
   	module.exports = iface;
 
-  	const Impl = requireURLSearchParamsImpl();
+  	const Impl = requireURLSearchParamsImpl(); 
   } (URLSearchParams));
 
+  var URLSearchParamsExports = URLSearchParams.exports;
+
   var hasRequiredURLImpl;
 
   function requireURLImpl () {
   	if (hasRequiredURLImpl) return URLImpl;
   	hasRequiredURLImpl = 1;
-  	const usm = urlStateMachine.exports;
+  	const usm = urlStateMachineExports;
   	const urlencoded$1 = urlencoded;
-  	const URLSearchParams$1 = URLSearchParams.exports;
+  	const URLSearchParams = URLSearchParamsExports;
 
   	URLImpl.implementation = class URLImpl {
   	  constructor(constructorArgs) {
@@ -81854,7 +81935,7 @@
 
   	    // We cannot invoke the "new URLSearchParams object" algorithm without going through the constructor, which strips
   	    // question mark by default. Therefore the doNotStripQMark hack is used.
-  	    this._query = URLSearchParams$1.createImpl([query], { doNotStripQMark: true });
+  	    this._query = URLSearchParams.createImpl([query], { doNotStripQMark: true });
   	    this._query._url = this;
   	  }
 
@@ -82045,12 +82126,14 @@
   	return URLImpl;
   }
 
+  URL$1.exports;
+
   (function (module) {
 
   	const conversions = lib;
-  	const utils$1 = utils.exports;
+  	const utils = utilsExports;
 
-  	const impl = utils$1.implSymbol;
+  	const impl = utils.implSymbol;
 
   	class URL {
   	  constructor(url) {
@@ -82263,8 +82346,8 @@
   	      throw new TypeError("Illegal invocation");
   	    }
 
-  	    return utils$1.getSameObject(this, "searchParams", () => {
-  	      return utils$1.tryWrapperForImpl(this[impl]["searchParams"]);
+  	    return utils.getSameObject(this, "searchParams", () => {
+  	      return utils.tryWrapperForImpl(this[impl]["searchParams"]);
   	    });
   	  }
 
@@ -82310,7 +82393,7 @@
   	  _mixedIntoPredicates: [],
   	  is(obj) {
   	    if (obj) {
-  	      if (utils$1.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+  	      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
   	        return true;
   	      }
   	      for (const isMixedInto of module.exports._mixedIntoPredicates) {
@@ -82327,7 +82410,7 @@
   	        return true;
   	      }
 
-  	      const wrapper = utils$1.wrapperForImpl(obj);
+  	      const wrapper = utils.wrapperForImpl(obj);
   	      for (const isMixedInto of module.exports._mixedIntoPredicates) {
   	        if (isMixedInto(wrapper)) {
   	          return true;
@@ -82338,7 +82421,7 @@
   	  },
   	  convert(obj, { context = "The provided value" } = {}) {
   	    if (module.exports.is(obj)) {
-  	      return utils$1.implForWrapper(obj);
+  	      return utils.implForWrapper(obj);
   	    }
   	    throw new TypeError(`${context} is not of type 'URL'.`);
   	  },
@@ -82351,7 +82434,7 @@
   	  createImpl(constructorArgs, privateData) {
   	    let obj = Object.create(URL.prototype);
   	    obj = this.setup(obj, constructorArgs, privateData);
-  	    return utils$1.implForWrapper(obj);
+  	    return utils.implForWrapper(obj);
   	  },
   	  _internalSetup(obj) {},
   	  setup(obj, constructorArgs, privateData) {
@@ -82365,7 +82448,7 @@
   	      configurable: true
   	    });
 
-  	    obj[impl][utils$1.wrapperSymbol] = obj;
+  	    obj[impl][utils.wrapperSymbol] = obj;
   	    if (Impl.init) {
   	      Impl.init(obj[impl], privateData);
   	    }
@@ -82379,21 +82462,23 @@
   	}; // iface
   	module.exports = iface;
 
-  	const Impl = requireURLImpl();
+  	const Impl = requireURLImpl(); 
   } (URL$1));
 
-  publicApi.URL = URL$1.exports.interface;
-  publicApi.URLSearchParams = URLSearchParams.exports.interface;
+  var URLExports = URL$1.exports;
 
-  publicApi.parseURL = urlStateMachine.exports.parseURL;
-  publicApi.basicURLParse = urlStateMachine.exports.basicURLParse;
-  publicApi.serializeURL = urlStateMachine.exports.serializeURL;
-  publicApi.serializeHost = urlStateMachine.exports.serializeHost;
-  publicApi.serializeInteger = urlStateMachine.exports.serializeInteger;
-  publicApi.serializeURLOrigin = urlStateMachine.exports.serializeURLOrigin;
-  publicApi.setTheUsername = urlStateMachine.exports.setTheUsername;
-  publicApi.setThePassword = urlStateMachine.exports.setThePassword;
-  publicApi.cannotHaveAUsernamePasswordPort = urlStateMachine.exports.cannotHaveAUsernamePasswordPort;
+  publicApi.URL = URLExports.interface;
+  publicApi.URLSearchParams = URLSearchParamsExports.interface;
+
+  publicApi.parseURL = urlStateMachineExports.parseURL;
+  publicApi.basicURLParse = urlStateMachineExports.basicURLParse;
+  publicApi.serializeURL = urlStateMachineExports.serializeURL;
+  publicApi.serializeHost = urlStateMachineExports.serializeHost;
+  publicApi.serializeInteger = urlStateMachineExports.serializeInteger;
+  publicApi.serializeURLOrigin = urlStateMachineExports.serializeURLOrigin;
+  publicApi.setTheUsername = urlStateMachineExports.setTheUsername;
+  publicApi.setThePassword = urlStateMachineExports.setThePassword;
+  publicApi.cannotHaveAUsernamePasswordPort = urlStateMachineExports.cannotHaveAUsernamePasswordPort;
 
   publicApi.percentDecode = urlencoded.percentDecode;
 
@@ -82869,7 +82954,7 @@
    * element is O(1). Removing elements from the set is not supported. Only
    * strings are supported for membership.
    */
-  class ArraySet$2 {
+  let ArraySet$2 = class ArraySet {
     constructor() {
       this._array = [];
       this._set = new Map();
@@ -82879,7 +82964,7 @@
      * Static method for creating ArraySet instances from an existing array.
      */
     static fromArray(aArray, aAllowDuplicates) {
-      const set = new ArraySet$2();
+      const set = new ArraySet();
       for (let i = 0, len = aArray.length; i < len; i++) {
         set.add(aArray[i], aAllowDuplicates);
       }
@@ -82954,7 +83039,7 @@
     toArray() {
       return this._array.slice();
     }
-  }
+  };
   arraySet.ArraySet = ArraySet$2;
 
   var mappingList = {};
@@ -82988,7 +83073,7 @@
    * performance conscious manner. It trades a negligible overhead in general
    * case for a large speedup in case of mappings being added in order.
    */
-  class MappingList$1 {
+  let MappingList$1 = class MappingList {
     constructor() {
       this._array = [];
       this._sorted = true;
@@ -83037,7 +83122,7 @@
       }
       return this._array;
     }
-  }
+  };
 
   mappingList.MappingList = MappingList$1;
 
@@ -83062,7 +83147,7 @@
    *   - file: The filename of the generated source.
    *   - sourceRoot: A root for all relative URLs in this source map.
    */
-  class SourceMapGenerator$1 {
+  let SourceMapGenerator$1 = class SourceMapGenerator {
     constructor(aArgs) {
       if (!aArgs) {
         aArgs = {};
@@ -83083,7 +83168,7 @@
      */
     static fromSourceMap(aSourceMapConsumer) {
       const sourceRoot = aSourceMapConsumer.sourceRoot;
-      const generator = new SourceMapGenerator$1({
+      const generator = new SourceMapGenerator({
         file: aSourceMapConsumer.file,
         sourceRoot
       });
@@ -83445,7 +83530,7 @@
     toString() {
       return JSON.stringify(this.toJSON());
     }
-  }
+  };
 
   SourceMapGenerator$1.prototype._version = 3;
   sourceMapGenerator.SourceMapGenerator = SourceMapGenerator$1;
@@ -83560,7 +83645,7 @@
   	  }
 
   	  return index;
-  	};
+  	}; 
   } (binarySearch$1));
 
   var readWasmBrowser = {exports: {}};
@@ -83586,7 +83671,9 @@
     mappingsWasm = input;
   };
 
-  const readWasm$1 = readWasmBrowser.exports;
+  var readWasmBrowserExports = readWasmBrowser.exports;
+
+  const readWasm$1 = readWasmBrowserExports;
 
   /**
    * Provide the JIT with a nice shape / hidden class.
@@ -83705,7 +83792,7 @@
   const util = util$3;
   const binarySearch = binarySearch$1;
   const ArraySet = arraySet.ArraySet;
-  const readWasm = readWasmBrowser.exports;
+  const readWasm = readWasmBrowserExports;
   const wasm = wasm$1;
 
   const INTERNAL = Symbol("smcInternal");
@@ -84911,9 +84998,11 @@
   	exports.generateMapFileComment = function (file, options) {
   	  var data = 'sourceMappingURL=' + file;
   	  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
-  	};
+  	}; 
   } (convertSourceMap));
 
+  var convert = /*@__PURE__*/getDefaultExportFromCjs(convertSourceMap);
+
   function identifier(name) {
     return { type: 'Identifier', name }
   }
@@ -85102,6 +85191,7 @@
   };
   const keywords = new Set(reservedWords.keyword);
   const reservedWordsStrictSet = new Set(reservedWords.strict);
+  new Set(reservedWords.strictBind);
 
   function isReservedWord(word, inModule) {
     return inModule && word === 'await' || word === 'enum'
@@ -85265,7 +85355,7 @@
     if (func.name === 'define') {
       let index = 0;
       let arg = args[index];
-      let name, deps;
+      let name, deps, params;
       if (arg.type === 'Literal') {
         if (length <= ++index || typeof arg.value !== 'string') return false
         name = arg;
@@ -85277,21 +85367,91 @@
         arg = args[index];
       }
       if (arg.type === 'FunctionExpression' || arg.type === 'ArrowFunctionExpression') {
-        return { namespace, func, name, deps, factory: arg }
+        if (!deps) {
+          ({ params, deps } = detectCjsDeps(arg) || {});
+        } else {
+          params = arg.params;
+        }
+        return { namespace, func, name, deps, params, factory: arg }
       }
       return arg.type === 'ObjectExpression' && { namespace, func, name, deps, output: arg }
     }
 
-    // require([deps], success, error)
+    // require([deps], success, [error])
     if (func.name === 'require') {
-      const deps = args[0];
-      if (deps.type === 'ArrayExpression' && length >= 2) {
+      const arg = args[0];
+      if (arg.type === 'ArrayExpression') {
+        if (length < 2) return false
         const body = args[1];
         if (body.type === 'FunctionExpression' || body.type === 'ArrowFunctionExpression') {
-          return { func, deps, body }
+          return { func, deps: arg, params: body.params, body }
+        }
+      } else if (arg.type === 'FunctionExpression' || arg.type === 'ArrowFunctionExpression') {
+        const { params, deps } = detectCjsDeps(arg) || {};
+        return { func, params, deps, body: arg }
+      }
+    }
+  }
+
+  // Checks if the expression parameters can support CJS-like require calls
+  // in the expression body.
+  function isCjsExpression(expr) {
+    const { params } = expr;
+    if (!params.length) return false
+    const param = params[0];
+    return param.type === 'Identifier' && param.name === 'require'
+  }
+
+  // Detects variable declarations with CJS-like require calls and such require
+  // calls on the first level of the expression body.
+  function detectCjsDeps(expr) {
+    if (!isCjsExpression(expr)) return
+    const params = [];
+    const namedDeps = [];
+    const unnamedDeps = [];
+    for (const statement of expr.body.body || []) {
+      const { type } = statement;
+      if (type === 'VariableDeclaration') {
+        for (const declarator of statement.declarations) {
+          const { id } = declarator;
+          if (id && id.type === 'Identifier') {
+            const { init } = declarator;
+            if (init && init.type === 'CallExpression') {
+              const { callee } = init;
+              if (callee.type === 'Identifier' && callee.name === 'require') {
+                const { arguments: args } = init;
+                if (args.length === 1) {
+                  const arg = args[0];
+                  if (arg.type === 'Literal') {
+                    params.push(id);
+                    namedDeps.push(arg);
+                  }
+                }
+              }
+            }
+          }
+        }
+      } else if (type === 'ExpressionStatement') {
+        const { expression } = statement;
+        if (expression.type === 'CallExpression') {
+          const { callee } = expression;
+          if (callee.type === 'Identifier' && callee.name === 'require') {
+            const { arguments: args } = expression;
+            if (args.length === 1) {
+              const arg = args[0];
+              if (arg.type === 'Literal') {
+                unnamedDeps.push(arg);
+              }
+            }
+          }
         }
       }
     }
+    let deps = [...namedDeps, ...unnamedDeps];
+    if (deps.length) {
+      deps = { type: 'ArrayExpression', elements: deps };
+      return { params, deps }
+    }
   }
 
   // Detects if a program contains statements calling define or require function.
@@ -85768,7 +85928,7 @@
           mapGenerator.setSourceContent(file, text);
         }
         if (sourceMap.inline) {
-          code += convertSourceMap.fromObject(mapGenerator.toJSON()).toComment();
+          code += convert.fromObject(mapGenerator.toJSON()).toComment();
         } else {
           map = mapGenerator.toJSON();
         }
@@ -85782,6 +85942,7 @@
 
   /* global module */
 
+
   const {
     // Allow using a different plugin alias than `esm` in the source code.
     pluginName,