meriyah 7.1.1 → 7.2.0

package/dist/meriyah.umd.js

@@ -4,7 +4,9 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.meriyah = {}));
 })(this, (function (exports) { 'use strict';
 
-  var version$1 = "7.1.1";
+  var version$1 = "7.2.0";
+  var packageJson = {
+  	version: version$1};
 
   const unicodeLookup = ((compressed, lookup) => {
       const result = new Uint32Array(69632);
@@ -490,7 +492,7 @@
               return 'RegularExpression';
           case 67174408:
           case 67174409:
-          case 131:
+          case 132:
               return 'TemplateLiteral';
           default:
               if ((t & 143360) === 143360)
@@ -798,7 +800,7 @@
       loc;
       description;
       constructor(start, end, type, ...params) {
-          const description = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+          const description = errorMessages[type].replaceAll(/%(\d+)/g, (_, i) => params[i]);
           const message = '[' + start.line + ':' + start.column + '-' + end.line + ':' + end.column + ']: ' + description;
           super(message);
           this.start = start.index;
@@ -833,7 +835,7 @@
       'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
       'this', 'throw', 'try', 'while', 'with',
       'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
-      'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of',
+      'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of', 'using',
       'enum', 'eval', 'arguments', 'escaped keyword', 'escaped future reserved keyword', 'reserved if strict', '#',
       'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
       'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
@@ -880,6 +882,7 @@
       let: 241737,
       null: 86023,
       of: 471156,
+      using: 209013,
       package: 36966,
       private: 36967,
       protected: 36968,
@@ -890,12 +893,12 @@
       true: 86022,
       with: 20579,
       yield: 241771,
-      enum: 86133,
-      eval: 537079926,
+      enum: 86134,
+      eval: 537079927,
       as: 77932,
-      arguments: 537079927,
-      target: 209029,
-      meta: 209030,
+      arguments: 537079928,
+      target: 209030,
+      meta: 209031,
       accessor: 12402,
   };
 
@@ -957,24 +960,24 @@
               if ((context & (2 | 2048)) === 0) {
                   return token | -2147483648;
               }
-              return -2147483528;
+              return -2147483527;
           }
           if (context & 1) {
               if (token === 36970) {
-                  return -2147483527;
+                  return -2147483526;
               }
               if ((token & 36864) === 36864) {
-                  return -2147483527;
+                  return -2147483526;
               }
               if ((token & 20480) === 20480) {
                   if (context & 262144 && (context & 8) === 0) {
                       return token | -2147483648;
                   }
                   else {
-                      return -2147483528;
+                      return -2147483527;
                   }
               }
-              return 209018 | -2147483648;
+              return 209019 | -2147483648;
           }
           if (context & 262144 &&
               (context & 8) === 0 &&
@@ -983,31 +986,31 @@
           }
           if (token === 241771) {
               return context & 262144
-                  ? 209018 | -2147483648
+                  ? 209019 | -2147483648
                   : context & 1024
-                      ? -2147483528
+                      ? -2147483527
                       : token | -2147483648;
           }
           if (token === 209005) {
-              return 209018 | -2147483648;
+              return 209019 | -2147483648;
           }
           if ((token & 36864) === 36864) {
               return token | 12288 | -2147483648;
           }
-          return -2147483528;
+          return -2147483527;
       }
       return 208897 | (hasEscape ? -2147483648 : 0);
   }
   function scanPrivateIdentifier(parser) {
       let char = advanceChar(parser);
       if (char === 92)
-          return 130;
+          return 131;
       const merged = consumePossibleSurrogatePair(parser);
       if (merged)
           char = merged;
       if (!isIdentifierStart(char))
           parser.report(96);
-      return 130;
+      return 131;
   }
   function scanIdentifierUnicodeEscape(parser) {
       if (parser.source.charCodeAt(parser.index + 1) !== 117) {
@@ -1213,7 +1216,7 @@
       if (isBigInt) {
           parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
           parser.tokenValue = BigInt(parser.tokenRaw.slice(0, -1).replaceAll('_', ''));
-          return 134283388;
+          return 134283389;
       }
       parser.tokenValue =
           kind & (1 | 2 | 8 | 4)
@@ -1524,12 +1527,14 @@
               const ch = advanceChar(parser);
               if (parser.currentChar === 123) {
                   let code = 0;
+                  let digits = 0;
                   while ((CharTypes[advanceChar(parser)] & 64) !== 0) {
                       code = (code << 4) | toHex(parser.currentChar);
                       if (code > 1114111)
                           return -5;
+                      digits++;
                   }
-                  if (parser.currentChar < 1 || parser.currentChar !== 125) {
+                  if (digits === 0 || parser.currentChar < 1 || parser.currentChar !== 125) {
                       return -4;
                   }
                   return code;
@@ -1580,6 +1585,7 @@
       const { index: start } = parser;
       let token = 67174409;
       let ret = '';
+      let hasCarriageReturn = false;
       let char = advanceChar(parser);
       while (char !== 96) {
           if (char === 36 && parser.source.charCodeAt(parser.index + 1) === 123) {
@@ -1589,6 +1595,8 @@
           }
           else if (char === 92) {
               char = advanceChar(parser);
+              if (char === 13)
+                  hasCarriageReturn = true;
               if (char > 0x7e) {
                   ret += String.fromCodePoint(char);
               }
@@ -1603,7 +1611,9 @@
                       parser.line = line;
                       parser.column = column;
                       ret = null;
-                      char = scanBadTemplate(parser, char);
+                      char = scanBadTemplate(parser, char, () => {
+                          hasCarriageReturn = true;
+                      });
                       if (char < 0)
                           token = 67174408;
                       break;
@@ -1614,10 +1624,13 @@
               }
           }
           else if (parser.index < parser.end) {
-              if (char === 13 && parser.source.charCodeAt(parser.index) === 10) {
-                  ret += String.fromCodePoint(char);
+              if (char === 13)
+                  hasCarriageReturn = true;
+              if (char === 13 && parser.source.charCodeAt(parser.index + 1) === 10) {
                   parser.currentChar = parser.source.charCodeAt(++parser.index);
               }
+              if (char === 13)
+                  char = 10;
               if (((char & 83) < 3 && char === 10) || (char ^ 8232) <= 1) {
                   parser.column = -1;
                   parser.line++;
@@ -1630,12 +1643,16 @@
       }
       advanceChar(parser);
       parser.tokenValue = ret;
-      parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+      const tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+      parser.tokenRaw = hasCarriageReturn ? tokenRaw.replaceAll(/\r\n?/g, '\n') : tokenRaw;
       return token;
   }
-  function scanBadTemplate(parser, ch) {
+  function scanBadTemplate(parser, ch, onCarriageReturn) {
       while (ch !== 96) {
           switch (ch) {
+              case 13:
+                  onCarriageReturn();
+                  break;
               case 36: {
                   const index = parser.index + 1;
                   if (index < parser.end && parser.source.charCodeAt(index) === 123) {
@@ -1666,42 +1683,42 @@
   }
 
   const TokenLookup = [
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      127,
-      135,
-      127,
-      127,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
       129,
       128,
+      136,
       128,
       128,
+      130,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
       128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      127,
       16842798,
       134283267,
-      130,
+      131,
       208897,
       8391477,
       8390213,
@@ -1730,7 +1747,7 @@
       1077936155,
       8390721,
       22,
-      132,
+      133,
       208897,
       208897,
       208897,
@@ -1758,11 +1775,11 @@
       208897,
       208897,
       69271571,
-      136,
+      137,
       20,
       8389959,
       208897,
-      131,
+      132,
       4096,
       4096,
       4096,
@@ -1793,7 +1810,7 @@
       8389702,
       1074790415,
       16842799,
-      128,
+      129,
   ];
   function nextToken(parser, context) {
       parser.flags = (parser.flags | 1) ^ 1;
@@ -1823,8 +1840,8 @@
                   case 1074790417:
                   case 18:
                   case 16842799:
-                  case 132:
-                  case 128:
+                  case 133:
+                  case 129:
                       advanceChar(parser);
                       return token;
                   case 208897:
@@ -1835,20 +1852,20 @@
                       return scanNumber(parser, context, 16 | 128);
                   case 134283267:
                       return scanString(parser, context, char);
-                  case 131:
+                  case 132:
                       return scanTemplate(parser, context);
-                  case 136:
+                  case 137:
                       return scanUnicodeIdentifier(parser, context);
-                  case 130:
+                  case 131:
                       return scanPrivateIdentifier(parser);
-                  case 127:
+                  case 128:
                       advanceChar(parser);
                       break;
-                  case 129:
+                  case 130:
                       state |= 1 | 4;
                       scanNewLine(parser);
                       break;
-                  case 135:
+                  case 136:
                       consumeLineFeed(parser, state);
                       state = (state & -5) | 1;
                       break;
@@ -2071,7 +2088,7 @@
                               advanceChar(parser);
                               return 4718634;
                           }
-                          return 276824445;
+                          return 276824446;
                       }
                       if (ch === 46) {
                           const index = parser.index + 1;
@@ -2079,7 +2096,7 @@
                               ch = source.charCodeAt(index);
                               if (!(ch >= 48 && ch <= 57)) {
                                   advanceChar(parser);
-                                  return 67108990;
+                                  return 67108991;
                               }
                           }
                       }
@@ -2187,7 +2204,7 @@
               parser.report(119);
           }
       }
-      if ((t & 20480) === 20480 || t === -2147483528) {
+      if ((t & 20480) === 20480 || t === -2147483527) {
           parser.report(102);
       }
       if (kind & (8 | 16) && (t & 255) === (241737 & 255)) {
@@ -2208,10 +2225,10 @@
           if ((t & 537079808) === 537079808) {
               parser.report(119);
           }
-          if (t === -2147483527) {
+          if (t === -2147483526) {
               parser.report(95);
           }
-          if (t === -2147483528) {
+          if (t === -2147483527) {
               parser.report(95);
           }
       }
@@ -2235,7 +2252,7 @@
           parser.report(97, 'yield');
       return ((t & 20480) === 20480 ||
           (t & 36864) === 36864 ||
-          t == -2147483527);
+          t == -2147483526);
   }
   function isPropertyWithPrivateFieldKey(expr) {
       return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
@@ -4450,7 +4467,7 @@
       '159': 376,
   };
   function decodeHTMLStrict(text) {
-      return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
+      return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
           if (key.charAt(1) === '#') {
               const secondChar = key.charAt(2);
               const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
@@ -4533,7 +4550,7 @@
       if (parser.options.raw)
           parser.tokenRaw = raw;
       parser.tokenValue = decodeHTMLStrict(raw);
-      parser.setToken(137);
+      parser.setToken(138);
   }
   function rescanJSXIdentifier(parser) {
       if ((parser.getToken() & 143360) === 143360) {
@@ -4936,7 +4953,7 @@
           context |= 1;
       skipHashBang(parser);
       const scope = parser.createScopeIfLexical();
-      let body = [];
+      let body;
       let sourceType = 'script';
       if (context & 2) {
           sourceType = 'module';
@@ -4994,7 +5011,7 @@
       return statements;
   }
   function parseModuleItem(parser, context, scope) {
-      if (parser.getToken() === 132) {
+      if (parser.getToken() === 133) {
           Object.assign(parser.leadingDecorators, {
               start: parser.tokenStart,
               decorators: parseDecorators(parser, context, undefined),
@@ -5021,13 +5038,21 @@
       switch (parser.getToken()) {
           case 86104:
               return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start);
-          case 132:
+          case 133:
           case 86094:
               return parseClassDeclaration(parser, context, scope, privateScope, 0);
           case 86090:
               return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
           case 241737:
               return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
+          case 209013:
+              return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+          case 209006:
+              if ((context & 2048 || (context & 2 && context & 8)) &&
+                  nextTokenIsUsingOnSameLine(parser)) {
+                  return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+              }
+              return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
           case 20564:
               parser.report(103, 'export');
           case 86106:
@@ -5111,15 +5136,18 @@
           default:
               expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart);
       }
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, expr, token, tokenValue, tokenStart);
+  }
+  function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart) {
       if (token & 143360 && parser.getToken() === 21) {
-          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, tokenStart);
+          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart);
       }
-      expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
-      expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
+      let expression = parseMemberOrUpdateExpression(parser, context, privateScope, initialExpression, 0, 0, tokenStart);
+      expression = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expression);
       if (parser.getToken() === 18) {
-          expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
+          expression = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expression);
       }
-      return parseExpressionStatement(parser, context, expr, tokenStart);
+      return parseExpressionStatement(parser, context, expression, tokenStart);
   }
   function parseBlock(parser, context, scope, privateScope, labels, start = parser.tokenStart, type = 'BlockStatement') {
       const body = [];
@@ -5308,9 +5336,14 @@
           while (parser.getToken() !== 20556 &&
               parser.getToken() !== 1074790415 &&
               parser.getToken() !== 20561) {
-              consequent.push(parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
+              const statement = parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
                   $: labels,
-              }));
+              });
+              if (statement.type === 'VariableDeclaration' &&
+                  (statement.kind === 'using' || statement.kind === 'await using')) {
+                  parser.report(30, statement.kind);
+              }
+              consequent.push(statement);
           }
           cases.push(parser.finishNode({
               type: 'SwitchCase',
@@ -5429,7 +5462,6 @@
   }
   function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
       let param = null;
-      let additionalScope = scope;
       if (consumeOpt(parser, context, 67174411)) {
           scope = scope?.createChildScope(4);
           param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
@@ -5443,7 +5475,7 @@
           }
           consume(parser, context | 32, 16);
       }
-      additionalScope = scope?.createChildScope(32);
+      const additionalScope = scope?.createChildScope(32);
       const body = parseBlock(parser, context, additionalScope, privateScope, { $: labels });
       return parser.finishNode({
           type: 'CatchClause',
@@ -5481,7 +5513,8 @@
       const { tokenValue, tokenStart } = parser;
       const token = parser.getToken();
       let expr = parseIdentifier(parser, context);
-      if (parser.getToken() & (143360 | 2097152)) {
+      if (parser.getToken() & (143360 | 2097152) &&
+          (parser.getToken() & 20480) !== 20480) {
           const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
           matchOrInsertSemicolon(parser, context | 32);
           return parser.finishNode({
@@ -5512,14 +5545,90 @@
       }
       return parseExpressionStatement(parser, context, expr, tokenStart);
   }
-  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin) {
+  function nextTokenIsUsingOnSameLine(parser) {
+      const { index: parserIndex, source } = parser;
+      let index = parserIndex;
+      while (index < parser.end) {
+          const char = source.charCodeAt(index);
+          if (char === 0x0a || char === 0x0d || char === 0x2028 || char === 0x2029)
+              return false;
+          if (/\s/u.test(source[index])) {
+              index++;
+              continue;
+          }
+          if (char === 0x2f && source.charCodeAt(index + 1) === 0x2a) {
+              index += 2;
+              while (index < parser.end) {
+                  const commentChar = source.charCodeAt(index);
+                  if (commentChar === 0x0a || commentChar === 0x0d || commentChar === 0x2028 || commentChar === 0x2029) {
+                      return false;
+                  }
+                  if (commentChar === 0x2a && source.charCodeAt(index + 1) === 0x2f) {
+                      index += 2;
+                      break;
+                  }
+                  index++;
+              }
+              continue;
+          }
+          break;
+      }
+      if (source.slice(index, index + 5) !== 'using')
+          return false;
+      const following = source.codePointAt(index + 5);
+      return following === undefined || (following !== 0x5c && !isIdentifierPart(following));
+  }
+  function isResourceBindingStart(token) {
+      return (token & 143360) === 143360 && (token & 20480) !== 20480;
+  }
+  function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+      const { tokenStart, tokenValue } = parser;
+      const token = parser.getToken();
+      const expression = parseIdentifier(parser, context);
+      if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+          if (origin & 4 && context & 8 && (context & 2) === 0) {
+              parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+          }
+          return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'using', tokenStart, 1);
+      }
+      parser.assignable = 1;
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 1, expression, token, tokenValue, tokenStart);
+  }
+  function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
       const start = parser.tokenStart;
-      nextToken(parser, context);
-      const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin);
+      if (context & 524288)
+          parser.report(177);
+      nextToken(parser, context | 32);
+      let argument;
+      if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+          const usingStart = parser.tokenStart;
+          const usingIdentifier = parseIdentifier(parser, context);
+          if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+              return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'await using', start, 1);
+          }
+          argument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+      }
+      else {
+          argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+      }
+      if (parser.getToken() === 8391735)
+          parser.report(33);
+      parser.assignable = 2;
+      const expression = parser.finishNode({
+          type: 'AwaitExpression',
+          argument,
+      }, start);
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 0, expression, 1048576, '', start);
+  }
+  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
+      const start = declarationStart;
+      if (!keywordConsumed)
+          nextToken(parser, context);
+      const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind);
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode({
           type: 'VariableDeclaration',
-          kind: kind & 8 ? 'let' : 'const',
+          kind: declarationKind ?? (kind & 8 ? 'let' : 'const'),
           declarations,
       }, start);
   }
@@ -5534,24 +5643,34 @@
           declarations,
       }, start);
   }
-  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin) {
+  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind) {
       let bindingCount = 1;
-      const list = [
-          parseVariableDeclaration(parser, context, scope, privateScope, kind, origin),
-      ];
+      const firstDeclaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+      const list = [firstDeclaration];
+      const resourceNames = declarationKind && parser.options.lexical ? new Set([firstDeclaration.id.name]) : undefined;
       while (consumeOpt(parser, context, 18)) {
           bindingCount++;
-          list.push(parseVariableDeclaration(parser, context, scope, privateScope, kind, origin));
+          const declaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+          if (resourceNames) {
+              const { name } = declaration.id;
+              if (resourceNames.has(name))
+                  parser.report(145, name);
+              resourceNames.add(name);
+          }
+          list.push(declaration);
       }
       if (bindingCount > 1 && origin & 32 && parser.getToken() & 262144) {
           parser.report(61, KeywordDescTable[parser.getToken() & 255]);
       }
       return list;
   }
-  function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin) {
+  function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind) {
       const { tokenStart } = parser;
       const token = parser.getToken();
       let init = null;
+      if (declarationKind && (token & 2097152) === 2097152) {
+          parser.report(50);
+      }
       const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
       if (parser.getToken() === 1077936155) {
           nextToken(parser, context | 32);
@@ -5566,7 +5685,7 @@
       }
       else if ((kind & 16 || (token & 2097152) > 0) &&
           (parser.getToken() & 262144) !== 262144) {
-          parser.report(59, kind & 16 ? 'const' : 'destructuring');
+          parser.report(59, declarationKind ?? (kind & 16 ? 'const' : 'destructuring'));
       }
       return parser.finishNode({
           type: 'VariableDeclarator',
@@ -5587,25 +5706,23 @@
       let init = null;
       let isVarDecl = parser.getToken() === 86088 ||
           parser.getToken() === 241737 ||
-          parser.getToken() === 86090;
+          parser.getToken() === 86090 ||
+          parser.getToken() === 209013;
+      let resourceDeclarationKind;
+      let consumedForOfDelimiter = false;
       let right;
       const { tokenStart } = parser;
       const token = parser.getToken();
       if (isVarDecl) {
           if (token === 241737) {
               init = parseIdentifier(parser, context);
-              if (parser.getToken() & (143360 | 2097152)) {
-                  if (parser.getToken() === 8673330) {
-                      if (context & 1)
-                          parser.report(67);
-                  }
-                  else {
-                      init = parser.finishNode({
-                          type: 'VariableDeclaration',
-                          kind: 'let',
-                          declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 8, 32),
-                      }, tokenStart);
-                  }
+              if (parser.getToken() & (143360 | 2097152) &&
+                  (parser.getToken() & 20480) !== 20480) {
+                  init = parser.finishNode({
+                      type: 'VariableDeclaration',
+                      kind: 'let',
+                      declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 8, 32),
+                  }, tokenStart);
                   parser.assignable = 1;
               }
               else if (context & 1) {
@@ -5619,6 +5736,81 @@
                       parser.report(115);
               }
           }
+          else if (token === 209013) {
+              const usingIdentifier = parseIdentifier(parser, context);
+              if ((parser.flags & 1) !== 0 || !isResourceBindingStart(parser.getToken())) {
+                  isVarDecl = false;
+                  parser.assignable = 1;
+                  init = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, tokenStart);
+              }
+              else if (parser.getToken() === 471156) {
+                  const ofStart = parser.tokenStart;
+                  const ofToken = parser.getToken();
+                  const ofValue = parser.tokenValue;
+                  const ofIdentifier = parseIdentifier(parser, context);
+                  if (parser.getToken() !== 1077936155 &&
+                      parser.getToken() !== 8673330 &&
+                      parser.getToken() !== 1074790417 &&
+                      parser.getToken() !== 18) {
+                      isVarDecl = false;
+                      consumedForOfDelimiter = true;
+                      parser.assignable = 1;
+                      init = usingIdentifier;
+                  }
+                  else {
+                      resourceDeclarationKind = 'using';
+                      validateBindingIdentifier(parser, context, 16, ofToken, 0);
+                      scope?.addBlockName(context, ofValue, 16, 32);
+                      let declarationInitializer = null;
+                      if (parser.getToken() === 1077936155) {
+                          nextToken(parser, context | 32);
+                          declarationInitializer = parseExpression(parser, context | 131072, privateScope, 1, 0, parser.tokenStart);
+                          if ((parser.getToken() & 262144) === 262144) {
+                              throw new ParseError(ofStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
+                          }
+                      }
+                      else if (parser.getToken() !== 8673330) {
+                          parser.report(59, resourceDeclarationKind);
+                      }
+                      const declarations = [
+                          parser.finishNode({
+                              type: 'VariableDeclarator',
+                              id: ofIdentifier,
+                              init: declarationInitializer,
+                          }, ofStart),
+                      ];
+                      const resourceNames = parser.options.lexical ? new Set([ofValue]) : undefined;
+                      while (consumeOpt(parser, context | 131072, 18)) {
+                          const declaration = parseVariableDeclaration(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind);
+                          if (resourceNames) {
+                              const { name } = declaration.id;
+                              if (resourceNames.has(name))
+                                  parser.report(145, name);
+                              resourceNames.add(name);
+                          }
+                          declarations.push(declaration);
+                      }
+                      if (declarations.length > 1 && parser.getToken() & 262144) {
+                          parser.report(61, KeywordDescTable[parser.getToken() & 255]);
+                      }
+                      init = parser.finishNode({
+                          type: 'VariableDeclaration',
+                          kind: resourceDeclarationKind,
+                          declarations,
+                      }, tokenStart);
+                      parser.assignable = 1;
+                  }
+              }
+              else {
+                  resourceDeclarationKind = 'using';
+                  init = parser.finishNode({
+                      type: 'VariableDeclaration',
+                      kind: resourceDeclarationKind,
+                      declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                  }, tokenStart);
+                  parser.assignable = 1;
+              }
+          }
           else {
               nextToken(parser, context);
               init = parser.finishNode(token === 86088
@@ -5635,6 +5827,42 @@
               parser.assignable = 1;
           }
       }
+      else if (token === 209006 &&
+          (context & 2048 || (context & 2 && context & 8))) {
+          if (context & 524288)
+              parser.report(177);
+          nextToken(parser, context | 32);
+          let awaitArgument;
+          if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+              const usingStart = parser.tokenStart;
+              const usingIdentifier = parseIdentifier(parser, context);
+              if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+                  resourceDeclarationKind = 'await using';
+                  isVarDecl = true;
+                  init = parser.finishNode({
+                      type: 'VariableDeclaration',
+                      kind: resourceDeclarationKind,
+                      declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                  }, tokenStart);
+                  parser.assignable = 1;
+              }
+              else {
+                  awaitArgument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+              }
+          }
+          else {
+              awaitArgument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+          }
+          if (!isVarDecl) {
+              if (parser.getToken() === 8391735)
+                  parser.report(33);
+              parser.assignable = 2;
+              init = parser.finishNode({
+                  type: 'AwaitExpression',
+                  argument: awaitArgument,
+              }, tokenStart);
+          }
+      }
       else if (token === 1074790417) {
           if (forAwait)
               parser.report(82);
@@ -5656,12 +5884,13 @@
       else {
           init = parseLeftHandSideExpression(parser, context | 131072, privateScope, 1, 0, 1);
       }
-      if ((parser.getToken() & 262144) === 262144) {
-          if (parser.getToken() === 471156) {
+      if (consumedForOfDelimiter || (parser.getToken() & 262144) === 262144) {
+          if (consumedForOfDelimiter || parser.getToken() === 471156) {
               if (parser.assignable & 2)
                   parser.report(80, forAwait ? 'await' : 'of');
               reinterpretToPattern(parser, init);
-              nextToken(parser, context | 32);
+              if (!consumedForOfDelimiter)
+                  nextToken(parser, context | 32);
               right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
               consume(parser, context | 32, 16);
               const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
@@ -5673,6 +5902,8 @@
                   await: forAwait,
               }, start);
           }
+          if (resourceDeclarationKind)
+              parser.report(30, 'in');
           if (parser.assignable & 2)
               parser.report(80, 'in');
           reinterpretToPattern(parser, init);
@@ -5726,7 +5957,7 @@
   function parseImportDeclaration(parser, context, scope) {
       const start = parser.tokenStart;
       nextToken(parser, context);
-      let source = null;
+      let source;
       const { tokenStart } = parser;
       let specifiers = [];
       if (parser.getToken() === 134283267) {
@@ -5870,7 +6101,7 @@
                   declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 0, parser.tokenStart);
                   break;
               }
-              case 132:
+              case 133:
               case 86094:
                   declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                   break;
@@ -5993,7 +6224,7 @@
               matchOrInsertSemicolon(parser, context | 32);
               break;
           }
-          case 132:
+          case 133:
           case 86094:
               declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
               break;
@@ -6331,7 +6562,7 @@
       const { tokenStart } = parser;
       nextToken(parser, context);
       switch (parser.getToken()) {
-          case 67108990:
+          case 67108991:
               parser.report(167);
           case 67174411: {
               if ((context & 512) === 0)
@@ -6378,10 +6609,13 @@
           switch (parser.getToken()) {
               case 67108877: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
-                  if (context & 16 && parser.getToken() === 130 && parser.tokenValue === 'super') {
+                  if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
                       parser.report(173);
                   }
-                  parser.assignable = 1;
+                  parser.assignable =
+                      (parser.flags & 2048) === 2048
+                          ? 2
+                          : 1;
                   const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
                   expr = parser.finishNode({
                       type: 'MemberExpression',
@@ -6406,7 +6640,7 @@
                   const { tokenStart } = parser;
                   const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
                   consume(parser, context, 20);
-                  parser.assignable = 1;
+                  parser.assignable = restoreHasOptionalChaining ? 2 : 1;
                   expr = parser.finishNode({
                       type: 'MemberExpression',
                       object: expr,
@@ -6447,7 +6681,7 @@
                   }
                   break;
               }
-              case 67108990: {
+              case 67108991: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
                   parser.flags |= 2048;
                   parser.assignable = 2;
@@ -6534,12 +6768,12 @@
   }
   function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
       if ((parser.getToken() & 143360) === 0 &&
-          parser.getToken() !== -2147483528 &&
           parser.getToken() !== -2147483527 &&
-          parser.getToken() !== 130) {
+          parser.getToken() !== -2147483526 &&
+          parser.getToken() !== 131) {
           parser.report(160);
       }
-      return parser.getToken() === 130
+      return parser.getToken() === 131
           ? parsePrivateIdentifier(parser, context, privateScope, 0)
           : parseIdentifier(parser, context);
   }
@@ -6632,7 +6866,7 @@
               return parseThisExpression(parser, context);
           case 65540:
               return parseRegExpLiteral(parser, context);
-          case 132:
+          case 133:
           case 86094:
               return parseClassExpression(parser, context, privateScope, inGroup, start);
           case 86109:
@@ -6643,9 +6877,9 @@
               return parseTemplate(parser, context, privateScope);
           case 86107:
               return parseNewExpression(parser, context, privateScope, inGroup);
-          case 134283388:
+          case 134283389:
               return parseBigIntLiteral(parser, context);
-          case 130:
+          case 131:
               return parsePrivateIdentifier(parser, context, privateScope, 0);
           case 86106:
               return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start);
@@ -6674,7 +6908,7 @@
           parser.report(169);
       nextToken(parser, context);
       const token = parser.getToken();
-      if (token !== 209030 && parser.tokenValue !== 'meta') {
+      if (token !== 209031 && parser.tokenValue !== 'meta') {
           parser.report(174);
       }
       else if (token & -2147483648) {
@@ -6722,7 +6956,7 @@
           const value = parseStringLiteral(parser, context);
           const keyContent = key.type === 'Literal' ? key.value : key.name;
           if (keysContent.has(keyContent)) {
-              parser.report(145, `${keyContent}`);
+              parser.report(145, keyContent);
           }
           keysContent.add(keyContent);
           attributes.push(parser.finishNode({
@@ -6819,6 +7053,7 @@
           consume(parser, context, 67174409);
           quasis.push(parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, true));
       }
+      parser.assignable = 2;
       return parser.finishNode({
           type: 'TemplateLiteral',
           expressions,
@@ -6897,7 +7132,7 @@
   }
   function parseLiteral(parser, context) {
       const { tokenValue, tokenRaw, tokenStart } = parser;
-      if (parser.getToken() === 134283388) {
+      if (parser.getToken() === 134283389) {
           return parseBigIntLiteral(parser, context);
       }
       const node = {
@@ -7414,9 +7649,9 @@
               let key = null;
               let value;
               if (parser.getToken() & 143360 ||
-                  parser.getToken() === -2147483528 ||
-                  parser.getToken() === -2147483527) {
-                  if (parser.getToken() === -2147483527)
+                  parser.getToken() === -2147483527 ||
+                  parser.getToken() === -2147483526) {
+                  if (parser.getToken() === -2147483526)
                       destructible |= 16;
                   key = parseIdentifier(parser, context);
                   if (parser.getToken() === 18 ||
@@ -7448,7 +7683,7 @@
                       else {
                           destructible |=
                               (token === 209006 ? 128 : 0) |
-                                  (token === -2147483528 ? 16 : 0);
+                                  (token === -2147483527 ? 16 : 0);
                           value = parser.cloneIdentifier(key);
                       }
                   }
@@ -7575,7 +7810,7 @@
                   }
                   else if (parser.getToken() & 143360) {
                       destructible |= 16;
-                      if (token === -2147483528)
+                      if (token === -2147483527)
                           parser.report(95);
                       if (token === 209005) {
                           if (parser.flags & 1)
@@ -8386,7 +8621,7 @@
       const id = parseIdentifier(parser, context | 32);
       const { tokenStart } = parser;
       if (consumeOpt(parser, context, 67108877)) {
-          if (context & 65536 && parser.getToken() === 209029) {
+          if (context & 65536 && parser.getToken() === 209030) {
               parser.assignable = 2;
               return parseMetaProperty(parser, context, id, start);
           }
@@ -8398,7 +8633,7 @@
       }
       const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
       context = (context | 131072) ^ 131072;
-      if (parser.getToken() === 67108990)
+      if (parser.getToken() === 67108991)
           parser.report(168);
       const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
       parser.assignable = 2;
@@ -8452,7 +8687,7 @@
           }, start);
       }
       let destructible = 0;
-      let expr = null;
+      let expr;
       let isNonSimpleParameterList = 0;
       parser.destructible =
           (parser.destructible | 256 | 128) ^
@@ -8599,7 +8834,7 @@
       let start;
       let decorators;
       if (parser.leadingDecorators.decorators.length) {
-          if (parser.getToken() === 132) {
+          if (parser.getToken() === 133) {
               parser.report(30, '@');
           }
           start = parser.leadingDecorators.start;
@@ -8688,7 +8923,7 @@
   function parseDecorators(parser, context, privateScope) {
       const list = [];
       if (parser.options.next) {
-          while (parser.getToken() === 132) {
+          while (parser.getToken() === 133) {
               list.push(parseDecoratorList(parser, context, privateScope));
           }
       }
@@ -8741,7 +8976,7 @@
       let kind = isStatic ? 32 : 0;
       let key = null;
       const token = parser.getToken();
-      if (token & (143360 | 36864) || token === -2147483528) {
+      if (token & (143360 | 36864) || token === -2147483527) {
           key = parseIdentifier(parser, context);
           switch (token) {
               case 36970:
@@ -8762,6 +8997,9 @@
                   break;
               case 209008:
                   if (parser.getToken() !== 67174411) {
+                      if (parser.getToken() === 8391476 && parser.flags & 1) {
+                          return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
+                      }
                       if ((parser.getToken() & 1073741824) === 1073741824) {
                           return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
                       }
@@ -8770,6 +9008,9 @@
                   break;
               case 209009:
                   if (parser.getToken() !== 67174411) {
+                      if (parser.getToken() === 8391476 && parser.flags & 1) {
+                          return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
+                      }
                       if ((parser.getToken() & 1073741824) === 1073741824) {
                           return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
                       }
@@ -8798,7 +9039,7 @@
           kind |= 8;
           nextToken(parser, context);
       }
-      else if (parser.getToken() === 130) {
+      else if (parser.getToken() === 131) {
           kind |= 8192;
           key = parsePrivateIdentifier(parser, context | 16, privateScope, 768);
       }
@@ -8808,7 +9049,7 @@
       else if (isStatic && token === 2162700) {
           return parseStaticBlock(parser, context | 16, scope, privateScope, start);
       }
-      else if (token === -2147483527) {
+      else if (token === -2147483526) {
           key = parseIdentifier(parser, context);
           if (parser.getToken() !== 67174411)
               parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8818,8 +9059,8 @@
       }
       if (kind & (8 | 16 | 768 | 1024)) {
           if (parser.getToken() & 143360 ||
-              parser.getToken() === -2147483528 ||
-              parser.getToken() === -2147483527) {
+              parser.getToken() === -2147483527 ||
+              parser.getToken() === -2147483526) {
               key = parseIdentifier(parser, context);
           }
           else if ((parser.getToken() & 134217728) === 134217728) {
@@ -8829,7 +9070,7 @@
               kind |= 2;
               key = parseComputedPropertyName(parser, context, privateScope, 0);
           }
-          else if (parser.getToken() === 130) {
+          else if (parser.getToken() === 131) {
               kind |= 8192;
               key = parsePrivateIdentifier(parser, context, privateScope, kind);
           }
@@ -8909,7 +9150,7 @@
       if (parser.getToken() === 1077936155) {
           nextToken(parser, context | 32);
           const { tokenStart } = parser;
-          if (parser.getToken() === 537079927)
+          if (parser.getToken() === 537079928)
               parser.report(119);
           const modifierFlags = 1024 |
               2048 |
@@ -8941,7 +9182,7 @@
   }
   function parseBindingPattern(parser, context, scope, privateScope, type, origin) {
       if (parser.getToken() & 143360 ||
-          ((context & 1) === 0 && parser.getToken() === -2147483527))
+          ((context & 1) === 0 && parser.getToken() === -2147483526))
           return parseAndClassifyIdentifier(parser, context, scope, type, origin);
       if ((parser.getToken() & 2097152) !== 2097152)
           parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8960,7 +9201,7 @@
           if ((token & 537079808) === 537079808) {
               parser.report(119);
           }
-          else if ((token & 36864) === 36864 || token === -2147483527) {
+          else if ((token & 36864) === 36864 || token === -2147483526) {
               parser.report(118);
           }
       }
@@ -9081,7 +9322,7 @@
       }
   }
   function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
-      if (parser.getToken() === 137)
+      if (parser.getToken() === 138)
           return parseJSXText(parser, context);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9095,7 +9336,7 @@
       parser.report(0);
   }
   function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
-      if (parser.getToken() === 137)
+      if (parser.getToken() === 138)
           return parseJSXText(parser, context);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9232,7 +9473,7 @@
       const { tokenStart } = parser;
       if (parser.getToken() === 14)
           return parseJSXSpreadChild(parser, context, privateScope, start);
-      let expression = null;
+      let expression;
       if (parser.getToken() === 1074790415) {
           if (isAttr)
               parser.report(157);
@@ -9286,7 +9527,7 @@
       }, start);
   }
 
-  const version = version$1;
+  const { version } = packageJson;
   function parseScript(source, options) {
       return parseSource(source, { ...options, sourceType: 'script' });
   }