@lvce-editor/server 0.16.9 → 0.16.10

package/static/{c1ca266 → 1334627}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -2125,7 +2125,7 @@ var init_Platform = __esm({
     platform2 = "remote";
     getAssetDir = () => {
       if (true) {
-        return "/c1ca266";
+        return "/1334627";
       }
       if (platform2 === Electron2) {
         return "../../../../..";
@@ -34645,7 +34645,7 @@ var init_ViewletQuickPickFocusIndex = __esm({
     focusIndex8 = async (state61, index) => {
       const { provider, maxVisibleItems, items, minLineY, maxLineY } = state61;
       if (provider.focusPick) {
-        await provider.focusPick(items[index]);
+        await provider.focusPick(items[index].pick);
       }
       if (index < minLineY + 1) {
         const minLineY2 = index;
@@ -45772,596 +45772,6 @@ var init_babel_parser = __esm({
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      const defaultOptions = {
-        sourceType: "script",
-        sourceFilename: void 0,
-        startColumn: 0,
-        startLine: 1,
-        allowAwaitOutsideFunction: false,
-        allowReturnOutsideFunction: false,
-        allowNewTargetOutsideFunction: false,
-        allowImportExportEverywhere: false,
-        allowSuperOutsideMethod: false,
-        allowUndeclaredExports: false,
-        plugins: [],
-        strictMode: null,
-        ranges: false,
-        tokens: false,
-        createParenthesizedExpressions: false,
-        errorRecovery: false,
-        attachComment: true,
-        annexB: true
-      };
-      function getOptions2(opts) {
-        if (opts && opts.annexB != null && opts.annexB !== false) {
-          throw new Error("The `annexB` option can only be set to `false`.");
-        }
-        const options2 = {};
-        for (const key of Object.keys(defaultOptions)) {
-          options2[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
-        }
-        return options2;
-      }
-      class TokContext {
-        constructor(token, preserveSpace) {
-          this.token = void 0;
-          this.preserveSpace = void 0;
-          this.token = token;
-          this.preserveSpace = !!preserveSpace;
-        }
-      }
-      const types = {
-        brace: new TokContext("{"),
-        j_oTag: new TokContext("<tag"),
-        j_cTag: new TokContext("</tag"),
-        j_expr: new TokContext("<tag>...</tag>", true)
-      };
-      {
-        types.template = new TokContext("`", true);
-      }
-      const beforeExpr = true;
-      const startsExpr = true;
-      const isLoop = true;
-      const isAssign = true;
-      const prefix = true;
-      const postfix = true;
-      class ExportedTokenType {
-        constructor(label, conf = {}) {
-          this.label = void 0;
-          this.keyword = void 0;
-          this.beforeExpr = void 0;
-          this.startsExpr = void 0;
-          this.rightAssociative = void 0;
-          this.isLoop = void 0;
-          this.isAssign = void 0;
-          this.prefix = void 0;
-          this.postfix = void 0;
-          this.binop = void 0;
-          this.label = label;
-          this.keyword = conf.keyword;
-          this.beforeExpr = !!conf.beforeExpr;
-          this.startsExpr = !!conf.startsExpr;
-          this.rightAssociative = !!conf.rightAssociative;
-          this.isLoop = !!conf.isLoop;
-          this.isAssign = !!conf.isAssign;
-          this.prefix = !!conf.prefix;
-          this.postfix = !!conf.postfix;
-          this.binop = conf.binop != null ? conf.binop : null;
-          {
-            this.updateContext = null;
-          }
-        }
-      }
-      const keywords$1 = /* @__PURE__ */ new Map();
-      function createKeyword(name124, options2 = {}) {
-        options2.keyword = name124;
-        const token = createToken(name124, options2);
-        keywords$1.set(name124, token);
-        return token;
-      }
-      function createBinop(name124, binop) {
-        return createToken(name124, {
-          beforeExpr,
-          binop
-        });
-      }
-      let tokenTypeCounter = -1;
-      const tokenTypes = [];
-      const tokenLabels = [];
-      const tokenBinops = [];
-      const tokenBeforeExprs = [];
-      const tokenStartsExprs = [];
-      const tokenPrefixes = [];
-      function createToken(name124, options2 = {}) {
-        var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
-        ++tokenTypeCounter;
-        tokenLabels.push(name124);
-        tokenBinops.push((_options$binop = options2.binop) != null ? _options$binop : -1);
-        tokenBeforeExprs.push((_options$beforeExpr = options2.beforeExpr) != null ? _options$beforeExpr : false);
-        tokenStartsExprs.push((_options$startsExpr = options2.startsExpr) != null ? _options$startsExpr : false);
-        tokenPrefixes.push((_options$prefix = options2.prefix) != null ? _options$prefix : false);
-        tokenTypes.push(new ExportedTokenType(name124, options2));
-        return tokenTypeCounter;
-      }
-      function createKeywordLike(name124, options2 = {}) {
-        var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
-        ++tokenTypeCounter;
-        keywords$1.set(name124, tokenTypeCounter);
-        tokenLabels.push(name124);
-        tokenBinops.push((_options$binop2 = options2.binop) != null ? _options$binop2 : -1);
-        tokenBeforeExprs.push((_options$beforeExpr2 = options2.beforeExpr) != null ? _options$beforeExpr2 : false);
-        tokenStartsExprs.push((_options$startsExpr2 = options2.startsExpr) != null ? _options$startsExpr2 : false);
-        tokenPrefixes.push((_options$prefix2 = options2.prefix) != null ? _options$prefix2 : false);
-        tokenTypes.push(new ExportedTokenType("name", options2));
-        return tokenTypeCounter;
-      }
-      const tt = {
-        bracketL: createToken("[", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketHashL: createToken("#[", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketBarL: createToken("[|", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketR: createToken("]"),
-        bracketBarR: createToken("|]"),
-        braceL: createToken("{", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceBarL: createToken("{|", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceHashL: createToken("#{", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceR: createToken("}"),
-        braceBarR: createToken("|}"),
-        parenL: createToken("(", {
-          beforeExpr,
-          startsExpr
-        }),
-        parenR: createToken(")"),
-        comma: createToken(",", {
-          beforeExpr
-        }),
-        semi: createToken(";", {
-          beforeExpr
-        }),
-        colon: createToken(":", {
-          beforeExpr
-        }),
-        doubleColon: createToken("::", {
-          beforeExpr
-        }),
-        dot: createToken("."),
-        question: createToken("?", {
-          beforeExpr
-        }),
-        questionDot: createToken("?."),
-        arrow: createToken("=>", {
-          beforeExpr
-        }),
-        template: createToken("template"),
-        ellipsis: createToken("...", {
-          beforeExpr
-        }),
-        backQuote: createToken("`", {
-          startsExpr
-        }),
-        dollarBraceL: createToken("${", {
-          beforeExpr,
-          startsExpr
-        }),
-        templateTail: createToken("...`", {
-          startsExpr
-        }),
-        templateNonTail: createToken("...${", {
-          beforeExpr,
-          startsExpr
-        }),
-        at: createToken("@"),
-        hash: createToken("#", {
-          startsExpr
-        }),
-        interpreterDirective: createToken("#!..."),
-        eq: createToken("=", {
-          beforeExpr,
-          isAssign
-        }),
-        assign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        slashAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        xorAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        moduloAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        incDec: createToken("++/--", {
-          prefix,
-          postfix,
-          startsExpr
-        }),
-        bang: createToken("!", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        tilde: createToken("~", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        doubleCaret: createToken("^^", {
-          startsExpr
-        }),
-        doubleAt: createToken("@@", {
-          startsExpr
-        }),
-        pipeline: createBinop("|>", 0),
-        nullishCoalescing: createBinop("??", 1),
-        logicalOR: createBinop("||", 1),
-        logicalAND: createBinop("&&", 2),
-        bitwiseOR: createBinop("|", 3),
-        bitwiseXOR: createBinop("^", 4),
-        bitwiseAND: createBinop("&", 5),
-        equality: createBinop("==/!=/===/!==", 6),
-        lt: createBinop("</>/<=/>=", 7),
-        gt: createBinop("</>/<=/>=", 7),
-        relational: createBinop("</>/<=/>=", 7),
-        bitShift: createBinop("<</>>/>>>", 8),
-        bitShiftL: createBinop("<</>>/>>>", 8),
-        bitShiftR: createBinop("<</>>/>>>", 8),
-        plusMin: createToken("+/-", {
-          beforeExpr,
-          binop: 9,
-          prefix,
-          startsExpr
-        }),
-        modulo: createToken("%", {
-          binop: 10,
-          startsExpr
-        }),
-        star: createToken("*", {
-          binop: 10
-        }),
-        slash: createBinop("/", 10),
-        exponent: createToken("**", {
-          beforeExpr,
-          binop: 11,
-          rightAssociative: true
-        }),
-        _in: createKeyword("in", {
-          beforeExpr,
-          binop: 7
-        }),
-        _instanceof: createKeyword("instanceof", {
-          beforeExpr,
-          binop: 7
-        }),
-        _break: createKeyword("break"),
-        _case: createKeyword("case", {
-          beforeExpr
-        }),
-        _catch: createKeyword("catch"),
-        _continue: createKeyword("continue"),
-        _debugger: createKeyword("debugger"),
-        _default: createKeyword("default", {
-          beforeExpr
-        }),
-        _else: createKeyword("else", {
-          beforeExpr
-        }),
-        _finally: createKeyword("finally"),
-        _function: createKeyword("function", {
-          startsExpr
-        }),
-        _if: createKeyword("if"),
-        _return: createKeyword("return", {
-          beforeExpr
-        }),
-        _switch: createKeyword("switch"),
-        _throw: createKeyword("throw", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _try: createKeyword("try"),
-        _var: createKeyword("var"),
-        _const: createKeyword("const"),
-        _with: createKeyword("with"),
-        _new: createKeyword("new", {
-          beforeExpr,
-          startsExpr
-        }),
-        _this: createKeyword("this", {
-          startsExpr
-        }),
-        _super: createKeyword("super", {
-          startsExpr
-        }),
-        _class: createKeyword("class", {
-          startsExpr
-        }),
-        _extends: createKeyword("extends", {
-          beforeExpr
-        }),
-        _export: createKeyword("export"),
-        _import: createKeyword("import", {
-          startsExpr
-        }),
-        _null: createKeyword("null", {
-          startsExpr
-        }),
-        _true: createKeyword("true", {
-          startsExpr
-        }),
-        _false: createKeyword("false", {
-          startsExpr
-        }),
-        _typeof: createKeyword("typeof", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _void: createKeyword("void", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _delete: createKeyword("delete", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _do: createKeyword("do", {
-          isLoop,
-          beforeExpr
-        }),
-        _for: createKeyword("for", {
-          isLoop
-        }),
-        _while: createKeyword("while", {
-          isLoop
-        }),
-        _as: createKeywordLike("as", {
-          startsExpr
-        }),
-        _assert: createKeywordLike("assert", {
-          startsExpr
-        }),
-        _async: createKeywordLike("async", {
-          startsExpr
-        }),
-        _await: createKeywordLike("await", {
-          startsExpr
-        }),
-        _from: createKeywordLike("from", {
-          startsExpr
-        }),
-        _get: createKeywordLike("get", {
-          startsExpr
-        }),
-        _let: createKeywordLike("let", {
-          startsExpr
-        }),
-        _meta: createKeywordLike("meta", {
-          startsExpr
-        }),
-        _of: createKeywordLike("of", {
-          startsExpr
-        }),
-        _sent: createKeywordLike("sent", {
-          startsExpr
-        }),
-        _set: createKeywordLike("set", {
-          startsExpr
-        }),
-        _static: createKeywordLike("static", {
-          startsExpr
-        }),
-        _using: createKeywordLike("using", {
-          startsExpr
-        }),
-        _yield: createKeywordLike("yield", {
-          startsExpr
-        }),
-        _asserts: createKeywordLike("asserts", {
-          startsExpr
-        }),
-        _checks: createKeywordLike("checks", {
-          startsExpr
-        }),
-        _exports: createKeywordLike("exports", {
-          startsExpr
-        }),
-        _global: createKeywordLike("global", {
-          startsExpr
-        }),
-        _implements: createKeywordLike("implements", {
-          startsExpr
-        }),
-        _intrinsic: createKeywordLike("intrinsic", {
-          startsExpr
-        }),
-        _infer: createKeywordLike("infer", {
-          startsExpr
-        }),
-        _is: createKeywordLike("is", {
-          startsExpr
-        }),
-        _mixins: createKeywordLike("mixins", {
-          startsExpr
-        }),
-        _proto: createKeywordLike("proto", {
-          startsExpr
-        }),
-        _require: createKeywordLike("require", {
-          startsExpr
-        }),
-        _satisfies: createKeywordLike("satisfies", {
-          startsExpr
-        }),
-        _keyof: createKeywordLike("keyof", {
-          startsExpr
-        }),
-        _readonly: createKeywordLike("readonly", {
-          startsExpr
-        }),
-        _unique: createKeywordLike("unique", {
-          startsExpr
-        }),
-        _abstract: createKeywordLike("abstract", {
-          startsExpr
-        }),
-        _declare: createKeywordLike("declare", {
-          startsExpr
-        }),
-        _enum: createKeywordLike("enum", {
-          startsExpr
-        }),
-        _module: createKeywordLike("module", {
-          startsExpr
-        }),
-        _namespace: createKeywordLike("namespace", {
-          startsExpr
-        }),
-        _interface: createKeywordLike("interface", {
-          startsExpr
-        }),
-        _type: createKeywordLike("type", {
-          startsExpr
-        }),
-        _opaque: createKeywordLike("opaque", {
-          startsExpr
-        }),
-        name: createToken("name", {
-          startsExpr
-        }),
-        string: createToken("string", {
-          startsExpr
-        }),
-        num: createToken("num", {
-          startsExpr
-        }),
-        bigint: createToken("bigint", {
-          startsExpr
-        }),
-        decimal: createToken("decimal", {
-          startsExpr
-        }),
-        regexp: createToken("regexp", {
-          startsExpr
-        }),
-        privateName: createToken("#name", {
-          startsExpr
-        }),
-        eof: createToken("eof"),
-        jsxName: createToken("jsxName"),
-        jsxText: createToken("jsxText", {
-          beforeExpr: true
-        }),
-        jsxTagStart: createToken("jsxTagStart", {
-          startsExpr: true
-        }),
-        jsxTagEnd: createToken("jsxTagEnd"),
-        placeholder: createToken("%%", {
-          startsExpr: true
-        })
-      };
-      function tokenIsIdentifier(token) {
-        return token >= 93 && token <= 130;
-      }
-      function tokenKeywordOrIdentifierIsKeyword(token) {
-        return token <= 92;
-      }
-      function tokenIsKeywordOrIdentifier(token) {
-        return token >= 58 && token <= 130;
-      }
-      function tokenIsLiteralPropertyName(token) {
-        return token >= 58 && token <= 134;
-      }
-      function tokenComesBeforeExpression(token) {
-        return tokenBeforeExprs[token];
-      }
-      function tokenCanStartExpression(token) {
-        return tokenStartsExprs[token];
-      }
-      function tokenIsAssignment(token) {
-        return token >= 29 && token <= 33;
-      }
-      function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
-        return token >= 127 && token <= 129;
-      }
-      function tokenIsLoop(token) {
-        return token >= 90 && token <= 92;
-      }
-      function tokenIsKeyword(token) {
-        return token >= 58 && token <= 92;
-      }
-      function tokenIsOperator(token) {
-        return token >= 39 && token <= 59;
-      }
-      function tokenIsPostfix(token) {
-        return token === 34;
-      }
-      function tokenIsPrefix(token) {
-        return tokenPrefixes[token];
-      }
-      function tokenIsTSTypeOperator(token) {
-        return token >= 119 && token <= 121;
-      }
-      function tokenIsTSDeclarationStart(token) {
-        return token >= 122 && token <= 128;
-      }
-      function tokenLabelName(token) {
-        return tokenLabels[token];
-      }
-      function tokenOperatorPrecedence(token) {
-        return tokenBinops[token];
-      }
-      function tokenIsRightAssociative(token) {
-        return token === 57;
-      }
-      function tokenIsTemplate(token) {
-        return token >= 24 && token <= 25;
-      }
-      function getExportedToken(token) {
-        return tokenTypes[token];
-      }
-      {
-        tokenTypes[8].updateContext = (context) => {
-          context.pop();
-        };
-        tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
-          context.push(types.brace);
-        };
-        tokenTypes[22].updateContext = (context) => {
-          if (context[context.length - 1] === types.template) {
-            context.pop();
-          } else {
-            context.push(types.template);
-          }
-        };
-        tokenTypes[140].updateContext = (context) => {
-          context.push(types.j_expr, types.j_oTag);
-        };
-      }
       function _objectWithoutPropertiesLoose(source, excluded) {
         if (source == null)
           return {};
@@ -46470,6 +45880,7 @@ var init_babel_parser = __esm({
         AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
         AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
         AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
+        AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
         AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
         AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
         BadGetterArity: "A 'get' accessor must not have any formal parameters.",
@@ -46519,6 +45930,7 @@ var init_babel_parser = __esm({
         }) => `Unsyntactic ${type3 === "BreakStatement" ? "break" : "continue"}.`,
         IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
         IllegalReturn: "'return' outside of function.",
+        ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
         ImportBindingIsString: ({
           importName
         }) => `A string literal cannot be used as an imported binding.
@@ -47016,96 +46428,656 @@ var init_babel_parser = __esm({
               at: prop.key
             });
           } else {
-            super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
-          }
-        }
-        finishCallExpression(unfinished, optional) {
-          const node = super.finishCallExpression(unfinished, optional);
-          if (node.callee.type === "Import") {
-            node.type = "ImportExpression";
-            node.source = node.arguments[0];
-            if (this.hasPlugin("importAssertions")) {
-              var _node$arguments$;
-              node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
-            }
-            delete node.arguments;
-            delete node.callee;
-          }
-          return node;
-        }
-        toReferencedArguments(node) {
-          if (node.type === "ImportExpression") {
-            return;
-          }
-          super.toReferencedArguments(node);
-        }
-        parseExport(unfinished, decorators) {
-          const exportStartLoc = this.state.lastTokStartLoc;
-          const node = super.parseExport(unfinished, decorators);
-          switch (node.type) {
-            case "ExportAllDeclaration":
-              node.exported = null;
-              break;
-            case "ExportNamedDeclaration":
-              if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
-                node.type = "ExportAllDeclaration";
-                node.exported = node.specifiers[0].exported;
-                delete node.specifiers;
-              }
-            case "ExportDefaultDeclaration":
-              {
-                var _declaration$decorato;
-                const {
-                  declaration
-                } = node;
-                if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
-                  this.resetStartLocation(node, exportStartLoc);
-                }
-              }
-              break;
-          }
-          return node;
-        }
-        parseSubscript(base, startLoc, noCalls, state61) {
-          const node = super.parseSubscript(base, startLoc, noCalls, state61);
-          if (state61.optionalChainMember) {
-            if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
-              node.type = node.type.substring(8);
-            }
-            if (state61.stop) {
-              const chain = this.startNodeAtNode(node);
-              chain.expression = node;
-              return this.finishNode(chain, "ChainExpression");
-            }
-          } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
-            node.optional = false;
-          }
-          return node;
-        }
-        hasPropertyAsPrivateName(node) {
-          if (node.type === "ChainExpression") {
-            node = node.expression;
+            super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
+          }
+        }
+        finishCallExpression(unfinished, optional) {
+          const node = super.finishCallExpression(unfinished, optional);
+          if (node.callee.type === "Import") {
+            node.type = "ImportExpression";
+            node.source = node.arguments[0];
+            if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
+              var _node$arguments$;
+              node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
+            }
+            delete node.arguments;
+            delete node.callee;
+          }
+          return node;
+        }
+        toReferencedArguments(node) {
+          if (node.type === "ImportExpression") {
+            return;
+          }
+          super.toReferencedArguments(node);
+        }
+        parseExport(unfinished, decorators) {
+          const exportStartLoc = this.state.lastTokStartLoc;
+          const node = super.parseExport(unfinished, decorators);
+          switch (node.type) {
+            case "ExportAllDeclaration":
+              node.exported = null;
+              break;
+            case "ExportNamedDeclaration":
+              if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
+                node.type = "ExportAllDeclaration";
+                node.exported = node.specifiers[0].exported;
+                delete node.specifiers;
+              }
+            case "ExportDefaultDeclaration":
+              {
+                var _declaration$decorato;
+                const {
+                  declaration
+                } = node;
+                if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
+                  this.resetStartLocation(node, exportStartLoc);
+                }
+              }
+              break;
+          }
+          return node;
+        }
+        parseSubscript(base, startLoc, noCalls, state61) {
+          const node = super.parseSubscript(base, startLoc, noCalls, state61);
+          if (state61.optionalChainMember) {
+            if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
+              node.type = node.type.substring(8);
+            }
+            if (state61.stop) {
+              const chain = this.startNodeAtNode(node);
+              chain.expression = node;
+              return this.finishNode(chain, "ChainExpression");
+            }
+          } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
+            node.optional = false;
+          }
+          return node;
+        }
+        hasPropertyAsPrivateName(node) {
+          if (node.type === "ChainExpression") {
+            node = node.expression;
+          }
+          return super.hasPropertyAsPrivateName(node);
+        }
+        isObjectProperty(node) {
+          return node.type === "Property" && node.kind === "init" && !node.method;
+        }
+        isObjectMethod(node) {
+          return node.method || node.kind === "get" || node.kind === "set";
+        }
+        finishNodeAt(node, type3, endLoc) {
+          return toESTreeLocation(super.finishNodeAt(node, type3, endLoc));
+        }
+        resetStartLocation(node, startLoc) {
+          super.resetStartLocation(node, startLoc);
+          toESTreeLocation(node);
+        }
+        resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
+          super.resetEndLocation(node, endLoc);
+          toESTreeLocation(node);
+        }
+      };
+      class TokContext {
+        constructor(token, preserveSpace) {
+          this.token = void 0;
+          this.preserveSpace = void 0;
+          this.token = token;
+          this.preserveSpace = !!preserveSpace;
+        }
+      }
+      const types = {
+        brace: new TokContext("{"),
+        j_oTag: new TokContext("<tag"),
+        j_cTag: new TokContext("</tag"),
+        j_expr: new TokContext("<tag>...</tag>", true)
+      };
+      {
+        types.template = new TokContext("`", true);
+      }
+      const beforeExpr = true;
+      const startsExpr = true;
+      const isLoop = true;
+      const isAssign = true;
+      const prefix = true;
+      const postfix = true;
+      class ExportedTokenType {
+        constructor(label, conf = {}) {
+          this.label = void 0;
+          this.keyword = void 0;
+          this.beforeExpr = void 0;
+          this.startsExpr = void 0;
+          this.rightAssociative = void 0;
+          this.isLoop = void 0;
+          this.isAssign = void 0;
+          this.prefix = void 0;
+          this.postfix = void 0;
+          this.binop = void 0;
+          this.label = label;
+          this.keyword = conf.keyword;
+          this.beforeExpr = !!conf.beforeExpr;
+          this.startsExpr = !!conf.startsExpr;
+          this.rightAssociative = !!conf.rightAssociative;
+          this.isLoop = !!conf.isLoop;
+          this.isAssign = !!conf.isAssign;
+          this.prefix = !!conf.prefix;
+          this.postfix = !!conf.postfix;
+          this.binop = conf.binop != null ? conf.binop : null;
+          {
+            this.updateContext = null;
+          }
+        }
+      }
+      const keywords$1 = /* @__PURE__ */ new Map();
+      function createKeyword(name124, options2 = {}) {
+        options2.keyword = name124;
+        const token = createToken(name124, options2);
+        keywords$1.set(name124, token);
+        return token;
+      }
+      function createBinop(name124, binop) {
+        return createToken(name124, {
+          beforeExpr,
+          binop
+        });
+      }
+      let tokenTypeCounter = -1;
+      const tokenTypes = [];
+      const tokenLabels = [];
+      const tokenBinops = [];
+      const tokenBeforeExprs = [];
+      const tokenStartsExprs = [];
+      const tokenPrefixes = [];
+      function createToken(name124, options2 = {}) {
+        var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
+        ++tokenTypeCounter;
+        tokenLabels.push(name124);
+        tokenBinops.push((_options$binop = options2.binop) != null ? _options$binop : -1);
+        tokenBeforeExprs.push((_options$beforeExpr = options2.beforeExpr) != null ? _options$beforeExpr : false);
+        tokenStartsExprs.push((_options$startsExpr = options2.startsExpr) != null ? _options$startsExpr : false);
+        tokenPrefixes.push((_options$prefix = options2.prefix) != null ? _options$prefix : false);
+        tokenTypes.push(new ExportedTokenType(name124, options2));
+        return tokenTypeCounter;
+      }
+      function createKeywordLike(name124, options2 = {}) {
+        var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
+        ++tokenTypeCounter;
+        keywords$1.set(name124, tokenTypeCounter);
+        tokenLabels.push(name124);
+        tokenBinops.push((_options$binop2 = options2.binop) != null ? _options$binop2 : -1);
+        tokenBeforeExprs.push((_options$beforeExpr2 = options2.beforeExpr) != null ? _options$beforeExpr2 : false);
+        tokenStartsExprs.push((_options$startsExpr2 = options2.startsExpr) != null ? _options$startsExpr2 : false);
+        tokenPrefixes.push((_options$prefix2 = options2.prefix) != null ? _options$prefix2 : false);
+        tokenTypes.push(new ExportedTokenType("name", options2));
+        return tokenTypeCounter;
+      }
+      const tt = {
+        bracketL: createToken("[", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketHashL: createToken("#[", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketBarL: createToken("[|", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketR: createToken("]"),
+        bracketBarR: createToken("|]"),
+        braceL: createToken("{", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceBarL: createToken("{|", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceHashL: createToken("#{", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceR: createToken("}"),
+        braceBarR: createToken("|}"),
+        parenL: createToken("(", {
+          beforeExpr,
+          startsExpr
+        }),
+        parenR: createToken(")"),
+        comma: createToken(",", {
+          beforeExpr
+        }),
+        semi: createToken(";", {
+          beforeExpr
+        }),
+        colon: createToken(":", {
+          beforeExpr
+        }),
+        doubleColon: createToken("::", {
+          beforeExpr
+        }),
+        dot: createToken("."),
+        question: createToken("?", {
+          beforeExpr
+        }),
+        questionDot: createToken("?."),
+        arrow: createToken("=>", {
+          beforeExpr
+        }),
+        template: createToken("template"),
+        ellipsis: createToken("...", {
+          beforeExpr
+        }),
+        backQuote: createToken("`", {
+          startsExpr
+        }),
+        dollarBraceL: createToken("${", {
+          beforeExpr,
+          startsExpr
+        }),
+        templateTail: createToken("...`", {
+          startsExpr
+        }),
+        templateNonTail: createToken("...${", {
+          beforeExpr,
+          startsExpr
+        }),
+        at: createToken("@"),
+        hash: createToken("#", {
+          startsExpr
+        }),
+        interpreterDirective: createToken("#!..."),
+        eq: createToken("=", {
+          beforeExpr,
+          isAssign
+        }),
+        assign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        slashAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        xorAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        moduloAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        incDec: createToken("++/--", {
+          prefix,
+          postfix,
+          startsExpr
+        }),
+        bang: createToken("!", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        tilde: createToken("~", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        doubleCaret: createToken("^^", {
+          startsExpr
+        }),
+        doubleAt: createToken("@@", {
+          startsExpr
+        }),
+        pipeline: createBinop("|>", 0),
+        nullishCoalescing: createBinop("??", 1),
+        logicalOR: createBinop("||", 1),
+        logicalAND: createBinop("&&", 2),
+        bitwiseOR: createBinop("|", 3),
+        bitwiseXOR: createBinop("^", 4),
+        bitwiseAND: createBinop("&", 5),
+        equality: createBinop("==/!=/===/!==", 6),
+        lt: createBinop("</>/<=/>=", 7),
+        gt: createBinop("</>/<=/>=", 7),
+        relational: createBinop("</>/<=/>=", 7),
+        bitShift: createBinop("<</>>/>>>", 8),
+        bitShiftL: createBinop("<</>>/>>>", 8),
+        bitShiftR: createBinop("<</>>/>>>", 8),
+        plusMin: createToken("+/-", {
+          beforeExpr,
+          binop: 9,
+          prefix,
+          startsExpr
+        }),
+        modulo: createToken("%", {
+          binop: 10,
+          startsExpr
+        }),
+        star: createToken("*", {
+          binop: 10
+        }),
+        slash: createBinop("/", 10),
+        exponent: createToken("**", {
+          beforeExpr,
+          binop: 11,
+          rightAssociative: true
+        }),
+        _in: createKeyword("in", {
+          beforeExpr,
+          binop: 7
+        }),
+        _instanceof: createKeyword("instanceof", {
+          beforeExpr,
+          binop: 7
+        }),
+        _break: createKeyword("break"),
+        _case: createKeyword("case", {
+          beforeExpr
+        }),
+        _catch: createKeyword("catch"),
+        _continue: createKeyword("continue"),
+        _debugger: createKeyword("debugger"),
+        _default: createKeyword("default", {
+          beforeExpr
+        }),
+        _else: createKeyword("else", {
+          beforeExpr
+        }),
+        _finally: createKeyword("finally"),
+        _function: createKeyword("function", {
+          startsExpr
+        }),
+        _if: createKeyword("if"),
+        _return: createKeyword("return", {
+          beforeExpr
+        }),
+        _switch: createKeyword("switch"),
+        _throw: createKeyword("throw", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _try: createKeyword("try"),
+        _var: createKeyword("var"),
+        _const: createKeyword("const"),
+        _with: createKeyword("with"),
+        _new: createKeyword("new", {
+          beforeExpr,
+          startsExpr
+        }),
+        _this: createKeyword("this", {
+          startsExpr
+        }),
+        _super: createKeyword("super", {
+          startsExpr
+        }),
+        _class: createKeyword("class", {
+          startsExpr
+        }),
+        _extends: createKeyword("extends", {
+          beforeExpr
+        }),
+        _export: createKeyword("export"),
+        _import: createKeyword("import", {
+          startsExpr
+        }),
+        _null: createKeyword("null", {
+          startsExpr
+        }),
+        _true: createKeyword("true", {
+          startsExpr
+        }),
+        _false: createKeyword("false", {
+          startsExpr
+        }),
+        _typeof: createKeyword("typeof", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _void: createKeyword("void", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _delete: createKeyword("delete", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _do: createKeyword("do", {
+          isLoop,
+          beforeExpr
+        }),
+        _for: createKeyword("for", {
+          isLoop
+        }),
+        _while: createKeyword("while", {
+          isLoop
+        }),
+        _as: createKeywordLike("as", {
+          startsExpr
+        }),
+        _assert: createKeywordLike("assert", {
+          startsExpr
+        }),
+        _async: createKeywordLike("async", {
+          startsExpr
+        }),
+        _await: createKeywordLike("await", {
+          startsExpr
+        }),
+        _from: createKeywordLike("from", {
+          startsExpr
+        }),
+        _get: createKeywordLike("get", {
+          startsExpr
+        }),
+        _let: createKeywordLike("let", {
+          startsExpr
+        }),
+        _meta: createKeywordLike("meta", {
+          startsExpr
+        }),
+        _of: createKeywordLike("of", {
+          startsExpr
+        }),
+        _sent: createKeywordLike("sent", {
+          startsExpr
+        }),
+        _set: createKeywordLike("set", {
+          startsExpr
+        }),
+        _static: createKeywordLike("static", {
+          startsExpr
+        }),
+        _using: createKeywordLike("using", {
+          startsExpr
+        }),
+        _yield: createKeywordLike("yield", {
+          startsExpr
+        }),
+        _asserts: createKeywordLike("asserts", {
+          startsExpr
+        }),
+        _checks: createKeywordLike("checks", {
+          startsExpr
+        }),
+        _exports: createKeywordLike("exports", {
+          startsExpr
+        }),
+        _global: createKeywordLike("global", {
+          startsExpr
+        }),
+        _implements: createKeywordLike("implements", {
+          startsExpr
+        }),
+        _intrinsic: createKeywordLike("intrinsic", {
+          startsExpr
+        }),
+        _infer: createKeywordLike("infer", {
+          startsExpr
+        }),
+        _is: createKeywordLike("is", {
+          startsExpr
+        }),
+        _mixins: createKeywordLike("mixins", {
+          startsExpr
+        }),
+        _proto: createKeywordLike("proto", {
+          startsExpr
+        }),
+        _require: createKeywordLike("require", {
+          startsExpr
+        }),
+        _satisfies: createKeywordLike("satisfies", {
+          startsExpr
+        }),
+        _keyof: createKeywordLike("keyof", {
+          startsExpr
+        }),
+        _readonly: createKeywordLike("readonly", {
+          startsExpr
+        }),
+        _unique: createKeywordLike("unique", {
+          startsExpr
+        }),
+        _abstract: createKeywordLike("abstract", {
+          startsExpr
+        }),
+        _declare: createKeywordLike("declare", {
+          startsExpr
+        }),
+        _enum: createKeywordLike("enum", {
+          startsExpr
+        }),
+        _module: createKeywordLike("module", {
+          startsExpr
+        }),
+        _namespace: createKeywordLike("namespace", {
+          startsExpr
+        }),
+        _interface: createKeywordLike("interface", {
+          startsExpr
+        }),
+        _type: createKeywordLike("type", {
+          startsExpr
+        }),
+        _opaque: createKeywordLike("opaque", {
+          startsExpr
+        }),
+        name: createToken("name", {
+          startsExpr
+        }),
+        string: createToken("string", {
+          startsExpr
+        }),
+        num: createToken("num", {
+          startsExpr
+        }),
+        bigint: createToken("bigint", {
+          startsExpr
+        }),
+        decimal: createToken("decimal", {
+          startsExpr
+        }),
+        regexp: createToken("regexp", {
+          startsExpr
+        }),
+        privateName: createToken("#name", {
+          startsExpr
+        }),
+        eof: createToken("eof"),
+        jsxName: createToken("jsxName"),
+        jsxText: createToken("jsxText", {
+          beforeExpr: true
+        }),
+        jsxTagStart: createToken("jsxTagStart", {
+          startsExpr: true
+        }),
+        jsxTagEnd: createToken("jsxTagEnd"),
+        placeholder: createToken("%%", {
+          startsExpr: true
+        })
+      };
+      function tokenIsIdentifier(token) {
+        return token >= 93 && token <= 130;
+      }
+      function tokenKeywordOrIdentifierIsKeyword(token) {
+        return token <= 92;
+      }
+      function tokenIsKeywordOrIdentifier(token) {
+        return token >= 58 && token <= 130;
+      }
+      function tokenIsLiteralPropertyName(token) {
+        return token >= 58 && token <= 134;
+      }
+      function tokenComesBeforeExpression(token) {
+        return tokenBeforeExprs[token];
+      }
+      function tokenCanStartExpression(token) {
+        return tokenStartsExprs[token];
+      }
+      function tokenIsAssignment(token) {
+        return token >= 29 && token <= 33;
+      }
+      function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
+        return token >= 127 && token <= 129;
+      }
+      function tokenIsLoop(token) {
+        return token >= 90 && token <= 92;
+      }
+      function tokenIsKeyword(token) {
+        return token >= 58 && token <= 92;
+      }
+      function tokenIsOperator(token) {
+        return token >= 39 && token <= 59;
+      }
+      function tokenIsPostfix(token) {
+        return token === 34;
+      }
+      function tokenIsPrefix(token) {
+        return tokenPrefixes[token];
+      }
+      function tokenIsTSTypeOperator(token) {
+        return token >= 119 && token <= 121;
+      }
+      function tokenIsTSDeclarationStart(token) {
+        return token >= 122 && token <= 128;
+      }
+      function tokenLabelName(token) {
+        return tokenLabels[token];
+      }
+      function tokenOperatorPrecedence(token) {
+        return tokenBinops[token];
+      }
+      function tokenIsRightAssociative(token) {
+        return token === 57;
+      }
+      function tokenIsTemplate(token) {
+        return token >= 24 && token <= 25;
+      }
+      function getExportedToken(token) {
+        return tokenTypes[token];
+      }
+      {
+        tokenTypes[8].updateContext = (context) => {
+          context.pop();
+        };
+        tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
+          context.push(types.brace);
+        };
+        tokenTypes[22].updateContext = (context) => {
+          if (context[context.length - 1] === types.template) {
+            context.pop();
+          } else {
+            context.push(types.template);
           }
-          return super.hasPropertyAsPrivateName(node);
-        }
-        isObjectProperty(node) {
-          return node.type === "Property" && node.kind === "init" && !node.method;
-        }
-        isObjectMethod(node) {
-          return node.method || node.kind === "get" || node.kind === "set";
-        }
-        finishNodeAt(node, type3, endLoc) {
-          return toESTreeLocation(super.finishNodeAt(node, type3, endLoc));
-        }
-        resetStartLocation(node, startLoc) {
-          super.resetStartLocation(node, startLoc);
-          toESTreeLocation(node);
-        }
-        resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
-          super.resetEndLocation(node, endLoc);
-          toESTreeLocation(node);
-        }
-      };
+        };
+        tokenTypes[140].updateContext = (context) => {
+          context.push(types.j_expr, types.j_oTag);
+        };
+      }
       let nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
       let nonASCIIidentifierChars = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
       const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
@@ -47550,6 +47522,21 @@ var init_babel_parser = __esm({
             commentWS.leadingNode = null;
           }
         }
+        resetPreviousIdentifierLeadingComments(node) {
+          const {
+            commentStack
+          } = this.state;
+          const {
+            length
+          } = commentStack;
+          if (length === 0)
+            return;
+          if (commentStack[length - 1].trailingNode === node) {
+            commentStack[length - 1].trailingNode = null;
+          } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {
+            commentStack[length - 2].trailingNode = null;
+          }
+        }
         takeSurroundingComments(node, start4, end) {
           const {
             commentStack
@@ -48735,7 +48722,6 @@ var init_babel_parser = __esm({
             const char = String.fromCharCode(cp);
             if (VALID_REGEX_FLAGS.has(cp)) {
               if (cp === 118) {
-                this.expectPlugin("regexpUnicodeSets", nextPos());
                 if (mods.includes("u")) {
                   this.raise(Errors.IncompatibleRegExpUVFlags, {
                     at: nextPos()
@@ -49767,9 +49753,6 @@ var init_babel_parser = __esm({
       function hasTypeImportKind(node) {
         return node.importKind === "type" || node.importKind === "typeof";
       }
-      function isMaybeDefaultImport(type3) {
-        return tokenIsKeywordOrIdentifier(type3) && type3 !== 97;
-      }
       const exportSuggestions = {
         const: "declare export var",
         let: "declare export var",
@@ -51090,13 +51073,6 @@ var init_babel_parser = __esm({
           }
           super.assertModuleNodeAllowed(node);
         }
-        parseExport(node, decorators) {
-          const decl = super.parseExport(node, decorators);
-          if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
-            decl.exportKind = decl.exportKind || "value";
-          }
-          return decl;
-        }
         parseExportDeclaration(node) {
           if (this.isContextual(128)) {
             node.exportKind = "type";
@@ -51405,12 +51381,6 @@ var init_babel_parser = __esm({
           }
           return node;
         }
-        shouldParseDefaultImport(node) {
-          if (!hasTypeImportKind(node)) {
-            return super.shouldParseDefaultImport(node);
-          }
-          return isMaybeDefaultImport(this.state.type);
-        }
         checkImportReflection(node) {
           super.checkImportReflection(node);
           if (node.module && node.importKind !== "value") {
@@ -51423,28 +51393,29 @@ var init_babel_parser = __esm({
           specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
           node.specifiers.push(this.finishImportSpecifier(specifier, type3));
         }
-        maybeParseDefaultImportSpecifier(node) {
-          node.importKind = "value";
-          let kind = null;
-          if (this.match(87)) {
-            kind = "typeof";
-          } else if (this.isContextual(128)) {
-            kind = "type";
+        isPotentialImportPhase(isExport) {
+          if (super.isPotentialImportPhase(isExport))
+            return true;
+          if (this.isContextual(128)) {
+            if (!isExport)
+              return true;
+            const ch = this.lookaheadCharCode();
+            return ch === 123 || ch === 42;
           }
-          if (kind) {
-            const lh = this.lookahead();
-            const {
-              type: type3
-            } = lh;
-            if (kind === "type" && type3 === 55) {
-              this.unexpected(null, lh.type);
-            }
-            if (isMaybeDefaultImport(type3) || type3 === 5 || type3 === 55) {
-              this.next();
-              node.importKind = kind;
+          return !isExport && this.isContextual(87);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          super.applyImportPhase(node, isExport, phase, loc);
+          if (isExport) {
+            if (!phase && this.match(65)) {
+              return;
             }
+            node.exportKind = phase === "type" ? phase : "value";
+          } else {
+            if (phase === "type" && this.match(55))
+              this.unexpected();
+            node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
           }
-          return super.maybeParseDefaultImportSpecifier(node);
         }
         parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
           const firstIdent = specifier.imported;
@@ -54656,9 +54627,9 @@ var init_babel_parser = __esm({
           }
           return this.finishNode(node, "TSModuleDeclaration");
         }
-        tsParseImportEqualsDeclaration(node, isExport) {
+        tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
           node.isExport = isExport || false;
-          node.id = this.parseIdentifier();
+          node.id = maybeDefaultIdentifier || this.parseIdentifier();
           this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);
           this.expect(29);
           const moduleReference = this.tsParseModuleReference();
@@ -54686,6 +54657,7 @@ var init_babel_parser = __esm({
           }
           node.expression = super.parseExprAtom();
           this.expect(11);
+          this.sawUnambiguousESM = true;
           return this.finishNode(node, "TSExternalModuleReference");
         }
         tsLookAhead(f) {
@@ -54858,6 +54830,8 @@ var init_babel_parser = __esm({
             this.raise(TSErrors.EmptyTypeArguments, {
               at: node
             });
+          } else if (!this.state.inType && this.curContext() === types.brace) {
+            this.reScan_lt_gt();
           }
           this.expect(48);
           return this.finishNode(node, "TSTypeParameterInstantiation");
@@ -55095,20 +55069,42 @@ var init_babel_parser = __esm({
         }
         checkDuplicateExports() {
         }
+        isPotentialImportPhase(isExport) {
+          if (super.isPotentialImportPhase(isExport))
+            return true;
+          if (this.isContextual(128)) {
+            const ch = this.lookaheadCharCode();
+            return isExport ? ch === 123 || ch === 42 : ch !== 61;
+          }
+          return !isExport && this.isContextual(87);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          super.applyImportPhase(node, isExport, phase, loc);
+          if (isExport) {
+            node.exportKind = phase === "type" ? "type" : "value";
+          } else {
+            node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
+          }
+        }
         parseImport(node) {
-          node.importKind = "value";
-          if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) {
-            let ahead = this.lookahead();
-            if (this.isContextual(128) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) {
-              node.importKind = "type";
-              this.next();
-              ahead = this.lookahead();
-            }
-            if (tokenIsIdentifier(this.state.type) && ahead.type === 29) {
-              return this.tsParseImportEqualsDeclaration(node);
+          if (this.match(131)) {
+            node.importKind = "value";
+            return super.parseImport(node);
+          }
+          let importNode;
+          if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
+            node.importKind = "value";
+            return this.tsParseImportEqualsDeclaration(node);
+          } else if (this.isContextual(128)) {
+            const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
+            if (this.lookaheadCharCode() === 61) {
+              return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
+            } else {
+              importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
             }
+          } else {
+            importNode = super.parseImport(node);
           }
-          const importNode = super.parseImport(node);
           if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
             this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
               at: importNode
@@ -55119,17 +55115,18 @@ var init_babel_parser = __esm({
         parseExport(node, decorators) {
           if (this.match(83)) {
             this.next();
-            if (this.isContextual(128) && this.lookaheadCharCode() !== 61) {
-              node.importKind = "type";
-              this.next();
+            let maybeDefaultIdentifier = null;
+            if (this.isContextual(128) && this.isPotentialImportPhase(false)) {
+              maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
             } else {
               node.importKind = "value";
             }
-            return this.tsParseImportEqualsDeclaration(node, true);
+            return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
           } else if (this.eat(29)) {
             const assign = node;
             assign.expression = super.parseExpression();
             this.semicolon();
+            this.sawUnambiguousESM = true;
             return this.finishNode(assign, "TSExportAssignment");
           } else if (this.eatContextual(93)) {
             const decl = node;
@@ -55138,14 +55135,6 @@ var init_babel_parser = __esm({
             this.semicolon();
             return this.finishNode(decl, "TSNamespaceExportDeclaration");
           } else {
-            node.exportKind = "value";
-            if (this.isContextual(128)) {
-              const ch = this.lookaheadCharCode();
-              if (ch === 123 || ch === 42) {
-                this.next();
-                node.exportKind = "type";
-              }
-            }
             return super.parseExport(node, decorators);
           }
         }
@@ -56165,11 +56154,12 @@ var init_babel_parser = __esm({
           }
           return super.isExportDefaultSpecifier();
         }
-        maybeParseExportDefaultSpecifier(node) {
-          if (node.specifiers && node.specifiers.length > 0) {
+        maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
+          var _specifiers;
+          if ((_specifiers = node.specifiers) != null && _specifiers.length) {
             return true;
           }
-          return super.maybeParseExportDefaultSpecifier(node);
+          return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
         }
         checkExport(node) {
           const {
@@ -56323,8 +56313,8 @@ var init_babel_parser = __esm({
         }
         if (hasPlugin(plugins, "moduleAttributes")) {
           {
-            if (hasPlugin(plugins, "importAssertions")) {
-              throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
+            if (hasPlugin(plugins, "importAssertions") || hasPlugin(plugins, "importAttributes")) {
+              throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins.");
             }
             const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
             if (moduleAttributesVersionPluginOption !== "may-2020") {
@@ -56332,6 +56322,9 @@ var init_babel_parser = __esm({
             }
           }
         }
+        if (hasPlugin(plugins, "importAssertions") && hasPlugin(plugins, "importAttributes")) {
+          throw new Error("Cannot combine importAssertions and importAttributes plugins.");
+        }
         if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
           throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
         }
@@ -56350,6 +56343,36 @@ var init_babel_parser = __esm({
         placeholders
       };
       const mixinPluginNames = Object.keys(mixinPlugins);
+      const defaultOptions = {
+        sourceType: "script",
+        sourceFilename: void 0,
+        startColumn: 0,
+        startLine: 1,
+        allowAwaitOutsideFunction: false,
+        allowReturnOutsideFunction: false,
+        allowNewTargetOutsideFunction: false,
+        allowImportExportEverywhere: false,
+        allowSuperOutsideMethod: false,
+        allowUndeclaredExports: false,
+        plugins: [],
+        strictMode: null,
+        ranges: false,
+        tokens: false,
+        createParenthesizedExpressions: false,
+        errorRecovery: false,
+        attachComment: true,
+        annexB: true
+      };
+      function getOptions2(opts) {
+        if (opts && opts.annexB != null && opts.annexB !== false) {
+          throw new Error("The `annexB` option can only be set to `false`.");
+        }
+        const options2 = {};
+        for (const key of Object.keys(defaultOptions)) {
+          options2[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+        }
+        return options2;
+      }
       class ExpressionParser extends LValParser {
         checkProto(prop, isRecord, protoRef, refExpressionErrors) {
           if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
@@ -56855,19 +56878,24 @@ var init_babel_parser = __esm({
         atPossibleAsyncArrow(base) {
           return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
         }
+        expectImportAttributesPlugin() {
+          if (!this.hasPlugin("importAssertions")) {
+            this.expectPlugin("importAttributes");
+          }
+        }
         finishCallExpression(node, optional) {
           if (node.callee.type === "Import") {
             if (node.arguments.length === 2) {
               {
                 if (!this.hasPlugin("moduleAttributes")) {
-                  this.expectPlugin("importAssertions");
+                  this.expectImportAttributesPlugin();
                 }
               }
             }
             if (node.arguments.length === 0 || node.arguments.length > 2) {
               this.raise(Errors.ImportCallArity, {
                 at: node,
-                maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
+                maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
               });
             } else {
               for (const arg of node.arguments) {
@@ -56892,7 +56920,7 @@ var init_babel_parser = __esm({
             } else {
               this.expect(12);
               if (this.match(close9)) {
-                if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
+                if (dynamicImport && !this.hasPlugin("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
                   this.raise(Errors.ImportCallArgumentTrailingComma, {
                     at: this.state.lastTokStartLoc
                   });
@@ -58358,6 +58386,18 @@ var init_babel_parser = __esm({
             return true;
           }
         }
+        startsAwaitUsing() {
+          let next3 = this.nextTokenInLineStart();
+          if (this.isUnparsedContextual(next3, "using")) {
+            next3 = this.nextTokenInLineStartSince(next3 + 5);
+            const nextCh = this.codePointAtPos(next3);
+            if (this.chStartsBindingIdentifier(nextCh, next3)) {
+              this.expectPlugin("explicitResourceManagement");
+              return true;
+            }
+          }
+          return false;
+        }
         parseModuleItem() {
           return this.parseStatementLike(1 | 2 | 4 | 8);
         }
@@ -58424,6 +58464,21 @@ var init_babel_parser = __esm({
               return this.parseThrowStatement(node);
             case 73:
               return this.parseTryStatement(node);
+            case 96:
+              if (!this.state.containsEsc && this.startsAwaitUsing()) {
+                if (!this.isAwaitAllowed()) {
+                  this.raise(Errors.AwaitUsingNotInAsyncContext, {
+                    at: node
+                  });
+                } else if (!allowDeclaration) {
+                  this.raise(Errors.UnexpectedLexicalDeclaration, {
+                    at: node
+                  });
+                }
+                this.next();
+                return this.parseVarStatement(node, "await using");
+              }
+              break;
             case 105:
               if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
                 break;
@@ -58692,27 +58747,41 @@ var init_babel_parser = __esm({
             return this.parseFor(node, null);
           }
           const startsWithLet = this.isContextual(99);
-          const startsWithUsing = this.isContextual(105);
-          const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || startsWithUsing && this.startsUsingForOf();
-          if (this.match(74) || this.match(75) || isLetOrUsing) {
-            const initNode = this.startNode();
-            const kind = this.state.value;
-            this.next();
-            this.parseVar(initNode, true, kind);
-            const init2 = this.finishNode(initNode, "VariableDeclaration");
-            const isForIn = this.match(58);
-            if (isForIn && startsWithUsing) {
-              this.raise(Errors.ForInUsing, {
-                at: init2
-              });
-            }
-            if ((isForIn || this.isContextual(101)) && init2.declarations.length === 1) {
-              return this.parseForIn(node, init2, awaitAt);
-            }
-            if (awaitAt !== null) {
-              this.unexpected(awaitAt);
+          {
+            const startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
+            const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(105) && this.startsUsingForOf();
+            const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
+            if (this.match(74) || this.match(75) || isLetOrUsing) {
+              const initNode = this.startNode();
+              let kind;
+              if (startsWithAwaitUsing) {
+                kind = "await using";
+                if (!this.isAwaitAllowed()) {
+                  this.raise(Errors.AwaitUsingNotInAsyncContext, {
+                    at: this.state.startLoc
+                  });
+                }
+                this.next();
+              } else {
+                kind = this.state.value;
+              }
+              this.next();
+              this.parseVar(initNode, true, kind);
+              const init2 = this.finishNode(initNode, "VariableDeclaration");
+              const isForIn = this.match(58);
+              if (isForIn && starsWithUsingDeclaration) {
+                this.raise(Errors.ForInUsing, {
+                  at: init2
+                });
+              }
+              if ((isForIn || this.isContextual(101)) && init2.declarations.length === 1) {
+                return this.parseForIn(node, init2, awaitAt);
+              }
+              if (awaitAt !== null) {
+                this.unexpected(awaitAt);
+              }
+              return this.parseFor(node, init2);
             }
-            return this.parseFor(node, init2);
           }
           const startsWithAsync = this.isContextual(95);
           const refExpressionErrors = new ExpressionErrors();
@@ -58973,9 +59042,7 @@ var init_babel_parser = __esm({
             }
             body.push(stmt);
           }
-          if (afterBlockParse) {
-            afterBlockParse.call(this, hasStrictModeDirective);
-          }
+          afterBlockParse == null ? void 0 : afterBlockParse.call(this, hasStrictModeDirective);
           if (!oldStrict) {
             this.setStrict(false);
           }
@@ -59453,7 +59520,8 @@ var init_babel_parser = __esm({
           node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
         }
         parseExport(node, decorators) {
-          const hasDefault = this.maybeParseExportDefaultSpecifier(node);
+          const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
+          const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
           const parseAfterDefault = !hasDefault || this.eat(12);
           const hasStar = parseAfterDefault && this.eatExportStar(node);
           const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
@@ -59521,11 +59589,12 @@ var init_babel_parser = __esm({
         eatExportStar(node) {
           return this.eat(55);
         }
-        maybeParseExportDefaultSpecifier(node) {
-          if (this.isExportDefaultSpecifier()) {
-            this.expectPlugin("exportDefaultFrom");
-            const specifier = this.startNode();
-            specifier.exported = this.parseIdentifier(true);
+        maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
+          if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
+            this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
+            const id = maybeDefaultIdentifier || this.parseIdentifier(true);
+            const specifier = this.startNodeAtNode(id);
+            specifier.exported = id;
             node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
             return true;
           }
@@ -59573,8 +59642,8 @@ var init_babel_parser = __esm({
         isAsyncFunction() {
           if (!this.isContextual(95))
             return false;
-          const next3 = this.nextTokenStart();
-          return !lineBreak.test(this.input.slice(this.state.pos, next3)) && this.isUnparsedContextual(next3, "function");
+          const next3 = this.nextTokenInLineStart();
+          return this.isUnparsedContextual(next3, "function");
         }
         parseExportDefaultExpression() {
           const expr = this.startNode();
@@ -59648,11 +59717,8 @@ var init_babel_parser = __esm({
           if (this.eatContextual(97)) {
             node.source = this.parseImportSource();
             this.checkExport(node);
-            const assertions = this.maybeParseImportAssertions();
-            if (assertions) {
-              node.assertions = assertions;
-              this.checkJSONModuleImport(node);
-            }
+            this.maybeParseImportAttributes(node);
+            this.checkJSONModuleImport(node);
           } else if (expect2) {
             this.unexpected();
           }
@@ -59856,53 +59922,66 @@ var init_babel_parser = __esm({
             }
           }
         }
-        parseMaybeImportReflection(node) {
-          let isImportReflection = false;
-          if (this.isContextual(125)) {
-            const lookahead = this.lookahead();
-            const nextType = lookahead.type;
-            if (tokenIsIdentifier(nextType)) {
-              if (nextType !== 97) {
-                isImportReflection = true;
-              } else {
-                const nextNextTokenFirstChar = this.input.charCodeAt(this.nextTokenStartSince(lookahead.end));
-                if (nextNextTokenFirstChar === 102) {
-                  isImportReflection = true;
-                }
-              }
-            } else if (nextType !== 12) {
-              isImportReflection = true;
-            }
+        isPotentialImportPhase(isExport) {
+          return !isExport && this.isContextual(125);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          if (isExport) {
+            return;
           }
-          if (isImportReflection) {
-            this.expectPlugin("importReflection");
-            this.next();
+          if (phase === "module") {
+            this.expectPlugin("importReflection", loc);
             node.module = true;
           } else if (this.hasPlugin("importReflection")) {
             node.module = false;
           }
         }
-        parseImport(node) {
-          node.specifiers = [];
-          if (!this.match(131)) {
-            this.parseMaybeImportReflection(node);
-            const hasDefault = this.maybeParseDefaultImportSpecifier(node);
-            const parseNext = !hasDefault || this.eat(12);
-            const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
-            if (parseNext && !hasStar)
-              this.parseNamedImportSpecifiers(node);
-            this.expectContextual(97);
+        parseMaybeImportPhase(node, isExport) {
+          if (!this.isPotentialImportPhase(isExport)) {
+            this.applyImportPhase(node, isExport, null);
+            return null;
           }
-          node.source = this.parseImportSource();
-          const assertions = this.maybeParseImportAssertions();
-          if (assertions) {
-            node.assertions = assertions;
+          const phaseIdentifier = this.parseIdentifier(true);
+          const {
+            type: type3
+          } = this.state;
+          const isImportPhase = tokenIsKeywordOrIdentifier(type3) ? type3 !== 97 || this.lookaheadCharCode() === 102 : type3 !== 12;
+          if (isImportPhase) {
+            this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
+            this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
+            return null;
           } else {
-            const attributes = this.maybeParseModuleAttributes();
-            if (attributes) {
-              node.attributes = attributes;
-            }
+            this.applyImportPhase(node, isExport, null);
+            return phaseIdentifier;
+          }
+        }
+        isPrecedingIdImportPhase(phase) {
+          const {
+            type: type3
+          } = this.state;
+          return tokenIsIdentifier(type3) ? type3 !== 97 || this.lookaheadCharCode() === 102 : type3 !== 12;
+        }
+        parseImport(node) {
+          if (this.match(131)) {
+            return this.parseImportSourceAndAttributes(node);
           }
+          return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
+        }
+        parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
+          node.specifiers = [];
+          const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
+          const parseNext = !hasDefault || this.eat(12);
+          const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
+          if (parseNext && !hasStar)
+            this.parseNamedImportSpecifiers(node);
+          this.expectContextual(97);
+          return this.parseImportSourceAndAttributes(node);
+        }
+        parseImportSourceAndAttributes(node) {
+          var _node$specifiers;
+          (_node$specifiers = node.specifiers) != null ? _node$specifiers : node.specifiers = [];
+          node.source = this.parseImportSource();
+          this.maybeParseImportAttributes(node);
           this.checkImportReflection(node);
           this.checkJSONModuleImport(node);
           this.semicolon();
@@ -59913,9 +59992,6 @@ var init_babel_parser = __esm({
             this.unexpected();
           return this.parseExprAtom();
         }
-        shouldParseDefaultImport(node) {
-          return tokenIsIdentifier(this.state.type);
-        }
         parseImportSpecifierLocal(node, specifier, type3) {
           specifier.local = this.parseIdentifier();
           node.specifiers.push(this.finishImportSpecifier(specifier, type3));
@@ -59929,7 +60005,8 @@ var init_babel_parser = __esm({
           });
           return this.finishNode(specifier, type3);
         }
-        parseAssertEntries() {
+        parseImportAttributes() {
+          this.expect(5);
           const attrs = [];
           const attrNames = /* @__PURE__ */ new Set();
           do {
@@ -59959,17 +60036,10 @@ var init_babel_parser = __esm({
             node.value = this.parseStringLiteral(this.state.value);
             attrs.push(this.finishNode(node, "ImportAttribute"));
           } while (this.eat(12));
+          this.expect(8);
           return attrs;
         }
-        maybeParseModuleAttributes() {
-          if (this.match(76) && !this.hasPrecedingLineBreak()) {
-            this.expectPlugin("moduleAttributes");
-            this.next();
-          } else {
-            if (this.hasPlugin("moduleAttributes"))
-              return [];
-            return null;
-          }
+        parseModuleAttributes() {
           const attrs = [];
           const attributes = /* @__PURE__ */ new Set();
           do {
@@ -59994,27 +60064,61 @@ var init_babel_parser = __esm({
               });
             }
             node.value = this.parseStringLiteral(this.state.value);
-            this.finishNode(node, "ImportAttribute");
-            attrs.push(node);
+            attrs.push(this.finishNode(node, "ImportAttribute"));
           } while (this.eat(12));
           return attrs;
         }
-        maybeParseImportAssertions() {
-          if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
-            this.expectPlugin("importAssertions");
+        maybeParseImportAttributes(node) {
+          let attributes;
+          let useWith = false;
+          if (this.match(76)) {
+            if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
+              return;
+            }
+            this.next();
+            {
+              if (this.hasPlugin("moduleAttributes")) {
+                attributes = this.parseModuleAttributes();
+              } else {
+                this.expectImportAttributesPlugin();
+                attributes = this.parseImportAttributes();
+              }
+            }
+            useWith = true;
+          } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
+            if (this.hasPlugin("importAttributes")) {
+              if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
+                this.raise(Errors.ImportAttributesUseAssert, {
+                  at: this.state.startLoc
+                });
+              }
+              this.addExtra(node, "deprecatedAssertSyntax", true);
+            } else {
+              this.expectOnePlugin(["importAttributes", "importAssertions"]);
+            }
             this.next();
+            attributes = this.parseImportAttributes();
+          } else if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
+            attributes = [];
           } else {
-            if (this.hasPlugin("importAssertions"))
-              return [];
-            return null;
+            if (this.hasPlugin("moduleAttributes")) {
+              attributes = [];
+            } else
+              return;
+          }
+          if (!useWith && this.hasPlugin("importAssertions")) {
+            node.assertions = attributes;
+          } else {
+            node.attributes = attributes;
           }
-          this.eat(5);
-          const attrs = this.parseAssertEntries();
-          this.eat(8);
-          return attrs;
         }
-        maybeParseDefaultImportSpecifier(node) {
-          if (this.shouldParseDefaultImport(node)) {
+        maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
+          if (maybeDefaultIdentifier) {
+            const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
+            specifier.local = maybeDefaultIdentifier;
+            node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
+            return true;
+          } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
             this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
             return true;
           }