meriyah 7.1.1 → 7.2.0

package/dist/meriyah.mjs

@@ -1,4 +1,6 @@
-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);
@@ -484,7 +486,7 @@ function convertTokenType(t) {
             return 'RegularExpression';
         case 67174408:
         case 67174409:
-        case 131:
+        case 132:
             return 'TemplateLiteral';
         default:
             if ((t & 143360) === 143360)
@@ -792,7 +794,7 @@ class ParseError extends SyntaxError {
     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;
@@ -827,7 +829,7 @@ const KeywordDescTable = [
     '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'
@@ -874,6 +876,7 @@ const descKeywordTable = {
     let: 241737,
     null: 86023,
     of: 471156,
+    using: 209013,
     package: 36966,
     private: 36967,
     protected: 36968,
@@ -884,12 +887,12 @@ const descKeywordTable = {
     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,
 };
 
@@ -951,24 +954,24 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
             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 &&
@@ -977,31 +980,31 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
         }
         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) {
@@ -1207,7 +1210,7 @@ function scanNumber(parser, context, kind) {
     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)
@@ -1518,12 +1521,14 @@ function parseEscape(parser, context, first, isTemplate = 0) {
             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;
@@ -1574,6 +1579,7 @@ function scanTemplate(parser, context) {
     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) {
@@ -1583,6 +1589,8 @@ function scanTemplate(parser, context) {
         }
         else if (char === 92) {
             char = advanceChar(parser);
+            if (char === 13)
+                hasCarriageReturn = true;
             if (char > 0x7e) {
                 ret += String.fromCodePoint(char);
             }
@@ -1597,7 +1605,9 @@ function scanTemplate(parser, context) {
                     parser.line = line;
                     parser.column = column;
                     ret = null;
-                    char = scanBadTemplate(parser, char);
+                    char = scanBadTemplate(parser, char, () => {
+                        hasCarriageReturn = true;
+                    });
                     if (char < 0)
                         token = 67174408;
                     break;
@@ -1608,10 +1618,13 @@ function scanTemplate(parser, context) {
             }
         }
         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++;
@@ -1624,12 +1637,16 @@ function scanTemplate(parser, context) {
     }
     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) {
@@ -1660,42 +1677,42 @@ function scanTemplateTail(parser, context) {
 }
 
 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,
@@ -1724,7 +1741,7 @@ const TokenLookup = [
     1077936155,
     8390721,
     22,
-    132,
+    133,
     208897,
     208897,
     208897,
@@ -1752,11 +1769,11 @@ const TokenLookup = [
     208897,
     208897,
     69271571,
-    136,
+    137,
     20,
     8389959,
     208897,
-    131,
+    132,
     4096,
     4096,
     4096,
@@ -1787,7 +1804,7 @@ const TokenLookup = [
     8389702,
     1074790415,
     16842799,
-    128,
+    129,
 ];
 function nextToken(parser, context) {
     parser.flags = (parser.flags | 1) ^ 1;
@@ -1817,8 +1834,8 @@ function scanSingleToken(parser, context, state) {
                 case 1074790417:
                 case 18:
                 case 16842799:
-                case 132:
-                case 128:
+                case 133:
+                case 129:
                     advanceChar(parser);
                     return token;
                 case 208897:
@@ -1829,20 +1846,20 @@ function scanSingleToken(parser, context, state) {
                     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;
@@ -2065,7 +2082,7 @@ function scanSingleToken(parser, context, state) {
                             advanceChar(parser);
                             return 4718634;
                         }
-                        return 276824445;
+                        return 276824446;
                     }
                     if (ch === 46) {
                         const index = parser.index + 1;
@@ -2073,7 +2090,7 @@ function scanSingleToken(parser, context, state) {
                             ch = source.charCodeAt(index);
                             if (!(ch >= 48 && ch <= 57)) {
                                 advanceChar(parser);
-                                return 67108990;
+                                return 67108991;
                             }
                         }
                     }
@@ -2181,7 +2198,7 @@ function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
             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)) {
@@ -2202,10 +2219,10 @@ function validateFunctionName(parser, context, t) {
         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);
         }
     }
@@ -2229,7 +2246,7 @@ function isStrictReservedWord(parser, context, t) {
         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';
@@ -4444,7 +4461,7 @@ const decodeMap = {
     '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);
@@ -4527,7 +4544,7 @@ function nextJSXToken(parser) {
     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) {
@@ -4930,7 +4947,7 @@ function parseSource(source, rawOptions = {}, context = 0) {
         context |= 1;
     skipHashBang(parser);
     const scope = parser.createScopeIfLexical();
-    let body = [];
+    let body;
     let sourceType = 'script';
     if (context & 2) {
         sourceType = 'module';
@@ -4988,7 +5005,7 @@ function parseModuleItemList(parser, context, scope) {
     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),
@@ -5015,13 +5032,21 @@ function parseStatementListItem(parser, context, scope, privateScope, origin, la
     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:
@@ -5105,15 +5130,18 @@ function parseExpressionOrLabelledStatement(parser, context, scope, privateScope
         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 = [];
@@ -5302,9 +5330,14 @@ function parseSwitchStatement(parser, context, scope, privateScope, labels) {
         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',
@@ -5423,7 +5456,6 @@ function parseTryStatement(parser, context, scope, privateScope, labels) {
 }
 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
@@ -5437,7 +5469,7 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
         }
         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',
@@ -5475,7 +5507,8 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     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({
@@ -5506,14 +5539,90 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     }
     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);
 }
@@ -5528,24 +5637,34 @@ function parseVariableStatement(parser, context, scope, privateScope, origin) {
         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);
@@ -5560,7 +5679,7 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
     }
     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',
@@ -5581,25 +5700,23 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     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) {
@@ -5613,6 +5730,81 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                     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
@@ -5629,6 +5821,42 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
             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);
@@ -5650,12 +5878,13 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     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);
@@ -5667,6 +5896,8 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                 await: forAwait,
             }, start);
         }
+        if (resourceDeclarationKind)
+            parser.report(30, 'in');
         if (parser.assignable & 2)
             parser.report(80, 'in');
         reinterpretToPattern(parser, init);
@@ -5720,7 +5951,7 @@ function parseRestrictedIdentifier(parser, context, scope) {
 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) {
@@ -5864,7 +6095,7 @@ function parseExportDeclaration(parser, context, scope) {
                 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;
@@ -5987,7 +6218,7 @@ function parseExportDeclaration(parser, context, scope) {
             matchOrInsertSemicolon(parser, context | 32);
             break;
         }
-        case 132:
+        case 133:
         case 86094:
             declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
             break;
@@ -6325,7 +6556,7 @@ function parseSuperExpression(parser, context) {
     const { tokenStart } = parser;
     nextToken(parser, context);
     switch (parser.getToken()) {
-        case 67108990:
+        case 67108991:
             parser.report(167);
         case 67174411: {
             if ((context & 512) === 0)
@@ -6372,10 +6603,13 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
         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',
@@ -6400,7 +6634,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 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,
@@ -6441,7 +6675,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 }
                 break;
             }
-            case 67108990: {
+            case 67108991: {
                 nextToken(parser, (context | 262144 | 8) ^ 8);
                 parser.flags |= 2048;
                 parser.assignable = 2;
@@ -6528,12 +6762,12 @@ function parseOptionalChain(parser, context, privateScope, expr, start) {
 }
 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);
 }
@@ -6626,7 +6860,7 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             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:
@@ -6637,9 +6871,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             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);
@@ -6668,7 +6902,7 @@ function parseImportMetaExpression(parser, context, meta, start) {
         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) {
@@ -6716,7 +6950,7 @@ function parseImportAttributes(parser, context) {
         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({
@@ -6813,6 +7047,7 @@ function parseTemplate(parser, context, privateScope) {
         consume(parser, context, 67174409);
         quasis.push(parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, true));
     }
+    parser.assignable = 2;
     return parser.finishNode({
         type: 'TemplateLiteral',
         expressions,
@@ -6891,7 +7126,7 @@ function parseIdentifier(parser, context) {
 }
 function parseLiteral(parser, context) {
     const { tokenValue, tokenRaw, tokenStart } = parser;
-    if (parser.getToken() === 134283388) {
+    if (parser.getToken() === 134283389) {
         return parseBigIntLiteral(parser, context);
     }
     const node = {
@@ -7408,9 +7643,9 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
             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 ||
@@ -7442,7 +7677,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     else {
                         destructible |=
                             (token === 209006 ? 128 : 0) |
-                                (token === -2147483528 ? 16 : 0);
+                                (token === -2147483527 ? 16 : 0);
                         value = parser.cloneIdentifier(key);
                     }
                 }
@@ -7569,7 +7804,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 }
                 else if (parser.getToken() & 143360) {
                     destructible |= 16;
-                    if (token === -2147483528)
+                    if (token === -2147483527)
                         parser.report(95);
                     if (token === 209005) {
                         if (parser.flags & 1)
@@ -8380,7 +8615,7 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     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);
         }
@@ -8392,7 +8627,7 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     }
     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;
@@ -8446,7 +8681,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         }, start);
     }
     let destructible = 0;
-    let expr = null;
+    let expr;
     let isNonSimpleParameterList = 0;
     parser.destructible =
         (parser.destructible | 256 | 128) ^
@@ -8593,7 +8828,7 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     let start;
     let decorators;
     if (parser.leadingDecorators.decorators.length) {
-        if (parser.getToken() === 132) {
+        if (parser.getToken() === 133) {
             parser.report(30, '@');
         }
         start = parser.leadingDecorators.start;
@@ -8682,7 +8917,7 @@ function parseClassExpression(parser, context, privateScope, inGroup, start) {
 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));
         }
     }
@@ -8735,7 +8970,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     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:
@@ -8756,6 +8991,9 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                 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);
                     }
@@ -8764,6 +9002,9 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                 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);
                     }
@@ -8792,7 +9033,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         kind |= 8;
         nextToken(parser, context);
     }
-    else if (parser.getToken() === 130) {
+    else if (parser.getToken() === 131) {
         kind |= 8192;
         key = parsePrivateIdentifier(parser, context | 16, privateScope, 768);
     }
@@ -8802,7 +9043,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     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]);
@@ -8812,8 +9053,8 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     }
     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) {
@@ -8823,7 +9064,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             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);
         }
@@ -8903,7 +9144,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
     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 |
@@ -8935,7 +9176,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
 }
 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]);
@@ -8954,7 +9195,7 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
         if ((token & 537079808) === 537079808) {
             parser.report(119);
         }
-        else if ((token & 36864) === 36864 || token === -2147483527) {
+        else if ((token & 36864) === 36864 || token === -2147483526) {
             parser.report(118);
         }
     }
@@ -9075,7 +9316,7 @@ function parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSX
     }
 }
 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);
@@ -9089,7 +9330,7 @@ function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild
     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);
@@ -9226,7 +9467,7 @@ function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild,
     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);
@@ -9280,7 +9521,7 @@ function parseJSXIdentifier(parser, context) {
     }, start);
 }
 
-const version = version$1;
+const { version } = packageJson;
 function parseScript(source, options) {
     return parseSource(source, { ...options, sourceType: 'script' });
 }