@vue/compiler-sfc 3.5.16 → 3.5.18

package/dist/compiler-sfc.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.16
+* @vue/compiler-sfc v3.5.18
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -87,7 +87,7 @@ const PatchFlagNames = {
   [512]: `NEED_PATCH`,
   [1024]: `DYNAMIC_SLOTS`,
   [2048]: `DEV_ROOT_FRAGMENT`,
-  [-1]: `HOISTED`,
+  [-1]: `CACHED`,
   [-2]: `BAIL`
 };
 
@@ -1921,7 +1921,7 @@ class Tokenizer {
     this.buffer = input;
     while (this.index < this.buffer.length) {
       const c = this.buffer.charCodeAt(this.index);
-      if (c === 10) {
+      if (c === 10 && this.state !== 33) {
         this.newlines.push(this.index);
       }
       switch (this.state) {
@@ -2406,7 +2406,11 @@ function getAugmentedNamespace(n) {
   var f = n.default;
 	if (typeof f == "function") {
 		var a = function a () {
-			if (this instanceof a) {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch {}
+			if (isInstance) {
         return Reflect.construct(f, arguments, this.constructor);
 			}
 			return f.apply(this, arguments);
@@ -2550,9 +2554,6 @@ function requireLib () {
 	  }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
 	  DuplicateProto: "Redefinition of __proto__ property.",
 	  DuplicateRegExpFlags: "Duplicate regular expression flag.",
-	  DynamicImportPhaseRequiresImportExpressions: ({
-	    phase
-	  }) => `'import.${phase}(...)' can only be parsed when using the 'createImportExpressions' option.`,
 	  ElementAfterRest: "Rest element must be last element.",
 	  EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
 	  ExportBindingIsString: ({
@@ -2585,6 +2586,7 @@ function requireLib () {
 	  IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
 	  InvalidBigIntLiteral: "Invalid BigIntLiteral.",
 	  InvalidCodePoint: "Code point out of bounds.",
+	  InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
 	  InvalidCoverInitializedName: "Invalid shorthand property initializer.",
 	  InvalidDecimal: "Invalid decimal.",
 	  InvalidDigit: ({
@@ -2701,7 +2703,8 @@ function requireLib () {
 	    unexpected
 	  }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
 	  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
-	  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
+	  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
+	  UnexpectedVoidPattern: "Unexpected void binding.",
 	  UnsupportedBind: "Binding should be performed on object property.",
 	  UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
 	  UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
@@ -2722,6 +2725,8 @@ function requireLib () {
 	  VarRedeclaration: ({
 	    identifierName
 	  }) => `Identifier '${identifierName}' has already been declared.`,
+	  VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
+	  VoidPatternInitializer: "A void binding may not have an initializer.",
 	  YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
 	  YieldInParameter: "Yield expression is not allowed in formal parameters.",
 	  YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
@@ -2740,6 +2745,12 @@ function requireLib () {
 	  StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
 	  StrictWith: "'with' in strict mode."
 	};
+	var ParseExpressionErrors = {
+	  ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
+	  ParseExpressionExpectsEOF: ({
+	    unexpected
+	  }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
+	};
 	const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
 	var PipelineOperatorErrors = Object.assign({
 	  PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
@@ -2854,7 +2865,7 @@ function requireLib () {
 	  }
 	  return ParseErrorConstructors;
 	}
-	const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
+	const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
 	function createDefaultOptions() {
 	  return {
 	    sourceType: "script",
@@ -2902,6 +2913,17 @@ function requireLib () {
 	      throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
 	    }
 	  }
+	  if (options.sourceType === "commonjs") {
+	    if (opts.allowAwaitOutsideFunction != null) {
+	      throw new Error("The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`.");
+	    }
+	    if (opts.allowReturnOutsideFunction != null) {
+	      throw new Error("`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`.");
+	    }
+	    if (opts.allowNewTargetOutsideFunction != null) {
+	      throw new Error("`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`.");
+	    }
+	  }
 	  return options;
 	}
 	const {
@@ -3769,7 +3791,7 @@ function requireLib () {
 	    startsExpr
 	  }),
 	  placeholder: createToken("%%", {
-	    startsExpr: true
+	    startsExpr
 	  }),
 	  string: createToken("string", {
 	    startsExpr
@@ -3792,10 +3814,10 @@ function requireLib () {
 	  eof: createToken("eof"),
 	  jsxName: createToken("jsxName"),
 	  jsxText: createToken("jsxText", {
-	    beforeExpr: true
+	    beforeExpr
 	  }),
 	  jsxTagStart: createToken("jsxTagStart", {
-	    startsExpr: true
+	    startsExpr
 	  }),
 	  jsxTagEnd: createToken("jsxTagEnd")
 	};
@@ -3975,6 +3997,9 @@ function requireLib () {
 	  get allowDirectSuper() {
 	    return (this.currentThisScopeFlags() & 32) > 0;
 	  }
+	  get allowNewTarget() {
+	    return (this.currentThisScopeFlags() & 512) > 0;
+	  }
 	  get inClass() {
 	    return (this.currentThisScopeFlags() & 64) > 0;
 	  }
@@ -3990,7 +4015,7 @@ function requireLib () {
 	      if (flags & 128) {
 	        return true;
 	      }
-	      if (flags & (387 | 64)) {
+	      if (flags & (1667 | 64)) {
 	        return false;
 	      }
 	    }
@@ -3998,6 +4023,9 @@ function requireLib () {
 	  get inNonArrowFunction() {
 	    return (this.currentThisScopeFlags() & 2) > 0;
 	  }
+	  get inBareCaseStatement() {
+	    return (this.currentScope().flags & 256) > 0;
+	  }
 	  get treatFunctionsAsVar() {
 	    return this.treatFunctionsAsVarInScope(this.currentScope());
 	  }
@@ -4037,7 +4065,7 @@ function requireLib () {
 	        this.checkRedeclarationInScope(scope, name, bindingType, loc);
 	        scope.names.set(name, (scope.names.get(name) || 0) | 1);
 	        this.maybeExportDefined(scope, name);
-	        if (scope.flags & 387) break;
+	        if (scope.flags & 1667) break;
 	      }
 	    }
 	    if (this.parser.inModule && scope.flags & 1) {
@@ -4084,7 +4112,7 @@ function requireLib () {
 	      const {
 	        flags
 	      } = this.scopeStack[i];
-	      if (flags & 387) {
+	      if (flags & 1667) {
 	        return flags;
 	      }
 	    }
@@ -4094,7 +4122,7 @@ function requireLib () {
 	      const {
 	        flags
 	      } = this.scopeStack[i];
-	      if (flags & (387 | 64) && !(flags & 4)) {
+	      if (flags & (1667 | 64) && !(flags & 4)) {
 	        return flags;
 	      }
 	    }
@@ -5492,7 +5520,7 @@ function requireLib () {
 	  finishArrowValidation(node) {
 	    var _node$extra;
 	    this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
-	    this.scope.enter(2 | 4);
+	    this.scope.enter(514 | 4);
 	    super.checkParams(node, false, true);
 	    this.scope.exit();
 	  }
@@ -6035,7 +6063,7 @@ function requireLib () {
 	      this.next();
 	      const node = this.startNodeAt(startLoc);
 	      node.callee = base;
-	      node.arguments = super.parseCallExpressionArguments(11);
+	      node.arguments = super.parseCallExpressionArguments();
 	      base = this.finishNode(node, "CallExpression");
 	    } else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
 	      const state = this.state.clone();
@@ -6067,7 +6095,7 @@ function requireLib () {
 	      node.callee = base;
 	      node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
 	      this.expect(10);
-	      node.arguments = this.parseCallExpressionArguments(11);
+	      node.arguments = this.parseCallExpressionArguments();
 	      node.optional = true;
 	      return this.finishCallExpression(node, true);
 	    } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
@@ -6076,7 +6104,7 @@ function requireLib () {
 	      const result = this.tryParse(() => {
 	        node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
 	        this.expect(10);
-	        node.arguments = super.parseCallExpressionArguments(11);
+	        node.arguments = super.parseCallExpressionArguments();
 	        if (subscriptState.optionalChainMember) {
 	          node.optional = false;
 	        }
@@ -7276,14 +7304,14 @@ function requireLib () {
 	    return new TypeScriptScope(flags);
 	  }
 	  enter(flags) {
-	    if (flags === 256) {
+	    if (flags === 1024) {
 	      this.importsStack.push(new Set());
 	    }
 	    super.enter(flags);
 	  }
 	  exit() {
 	    const flags = super.exit();
-	    if (flags === 256) {
+	    if (flags === 1024) {
 	      this.importsStack.pop();
 	    }
 	    return flags;
@@ -7512,6 +7540,7 @@ function requireLib () {
 	    }
 	  }
 	  finalizeComment(commentWS) {
+	    var _node$options;
 	    const {
 	      comments
 	    } = commentWS;
@@ -7538,6 +7567,9 @@ function requireLib () {
 	          case "OptionalCallExpression":
 	            adjustInnerComments(node, node.arguments, commentWS);
 	            break;
+	          case "ImportExpression":
+	            adjustInnerComments(node, [node.source, (_node$options = node.options) != null ? _node$options : null], commentWS);
+	            break;
 	          case "FunctionDeclaration":
 	          case "FunctionExpression":
 	          case "ArrowFunctionExpression":
@@ -7595,20 +7627,6 @@ function requireLib () {
 	      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, start, end) {
 	    const {
 	      commentStack
@@ -9301,9 +9319,8 @@ function requireLib () {
 	    return this.state.type === token && !this.state.containsEsc;
 	  }
 	  isUnparsedContextual(nameStart, name) {
-	    const nameEnd = nameStart + name.length;
-	    if (this.input.slice(nameStart, nameEnd) === name) {
-	      const nextCh = this.input.charCodeAt(nameEnd);
+	    if (this.input.startsWith(name, nameStart)) {
+	      const nextCh = this.input.charCodeAt(nameStart + name.length);
 	      return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);
 	    }
 	    return false;
@@ -9406,9 +9423,10 @@ function requireLib () {
 	      shorthandAssignLoc,
 	      doubleProtoLoc,
 	      privateKeyLoc,
-	      optionalParametersLoc
+	      optionalParametersLoc,
+	      voidPatternLoc
 	    } = refExpressionErrors;
-	    const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;
+	    const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc || !!voidPatternLoc;
 	    if (!andThrow) {
 	      return hasErrors;
 	    }
@@ -9424,6 +9442,9 @@ function requireLib () {
 	    if (optionalParametersLoc != null) {
 	      this.unexpected(optionalParametersLoc);
 	    }
+	    if (voidPatternLoc != null) {
+	      this.raise(Errors.InvalidCoverDiscardElement, voidPatternLoc);
+	    }
 	  }
 	  isLiteralPropertyName() {
 	    return tokenIsLiteralPropertyName(this.state.type);
@@ -9471,14 +9492,22 @@ function requireLib () {
 	  }
 	  enterInitialScopes() {
 	    let paramFlags = 0;
-	    if (this.inModule) {
+	    if (this.inModule || this.optionFlags & 1) {
 	      paramFlags |= 2;
 	    }
 	    if (this.optionFlags & 32) {
 	      paramFlags |= 1;
 	    }
-	    this.scope.enter(1);
+	    const isCommonJS = !this.inModule && this.options.sourceType === "commonjs";
+	    if (isCommonJS || this.optionFlags & 2) {
+	      paramFlags |= 4;
+	    }
 	    this.prodParam.enter(paramFlags);
+	    let scopeFlags = isCommonJS ? 514 : 1;
+	    if (this.optionFlags & 4) {
+	      scopeFlags |= 512;
+	    }
+	    this.scope.enter(scopeFlags);
 	  }
 	  checkDestructuringPrivate(refExpressionErrors) {
 	    const {
@@ -9495,6 +9524,7 @@ function requireLib () {
 	    this.doubleProtoLoc = null;
 	    this.privateKeyLoc = null;
 	    this.optionalParametersLoc = null;
+	    this.voidPatternLoc = null;
 	  }
 	}
 	class Node {
@@ -9626,6 +9656,7 @@ function requireLib () {
 	      case "ArrayPattern":
 	      case "AssignmentPattern":
 	      case "RestElement":
+	      case "VoidPattern":
 	        break;
 	      case "ObjectExpression":
 	        this.castNodeTo(node, "ObjectPattern");
@@ -9665,6 +9696,9 @@ function requireLib () {
 	        }
 	        this.castNodeTo(node, "AssignmentPattern");
 	        delete node.operator;
+	        if (node.left.type === "VoidPattern") {
+	          this.raise(Errors.VoidPatternInitializer, node.left);
+	        }
 	        this.toAssignable(node.left, isLHS);
 	        break;
 	      case "ParenthesizedExpression":
@@ -9720,6 +9754,7 @@ function requireLib () {
 	      case "ArrayPattern":
 	      case "AssignmentPattern":
 	      case "RestElement":
+	      case "VoidPattern":
 	        return true;
 	      case "ObjectExpression":
 	        {
@@ -9765,7 +9800,11 @@ function requireLib () {
 	  parseRestBinding() {
 	    const node = this.startNode();
 	    this.next();
-	    node.argument = this.parseBindingAtom();
+	    const argument = this.parseBindingAtom();
+	    if (argument.type === "VoidPattern") {
+	      this.raise(Errors.UnexpectedVoidPattern, argument);
+	    }
+	    node.argument = argument;
 	    return this.finishNode(node, "RestElement");
 	  }
 	  parseBindingAtom() {
@@ -9779,6 +9818,8 @@ function requireLib () {
 	        }
 	      case 5:
 	        return this.parseObjectLike(8, true);
+	      case 88:
+	        return this.parseVoidPattern(null);
 	    }
 	    return this.parseIdentifier();
 	  }
@@ -9823,7 +9864,12 @@ function requireLib () {
 	  }
 	  parseBindingRestProperty(prop) {
 	    this.next();
-	    prop.argument = this.parseIdentifier();
+	    if (this.hasPlugin("discardBinding") && this.match(88)) {
+	      prop.argument = this.parseVoidPattern(null);
+	      this.raise(Errors.UnexpectedVoidPattern, prop.argument);
+	    } else {
+	      prop.argument = this.parseIdentifier();
+	    }
 	    this.checkCommaAfterRest(125);
 	    return this.finishNode(prop, "RestElement");
 	  }
@@ -9866,6 +9912,9 @@ function requireLib () {
 	    left = left != null ? left : this.parseBindingAtom();
 	    if (!this.eat(29)) return left;
 	    const node = this.startNodeAt(startLoc);
+	    if (left.type === "VoidPattern") {
+	      this.raise(Errors.VoidPatternInitializer, left);
+	    }
 	    node.left = left;
 	    node.right = this.parseMaybeAssignAllowIn();
 	    return this.finishNode(node, "AssignmentPattern");
@@ -9884,6 +9933,8 @@ function requireLib () {
 	        return "elements";
 	      case "ObjectPattern":
 	        return "properties";
+	      case "VoidPattern":
+	        return true;
 	    }
 	    return false;
 	  }
@@ -9922,6 +9973,8 @@ function requireLib () {
 	        }
 	      }
 	      return;
+	    } else if (type === "VoidPattern" && ancestor.type === "CatchClause") {
+	      this.raise(Errors.VoidPatternCatchClauseParam, expression);
 	    }
 	    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
 	    if (validity === true) return;
@@ -10030,7 +10083,7 @@ function requireLib () {
 	  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
 	  DuplicateAccessibilityModifier: ({
 	    modifier
-	  }) => `Accessibility modifier already seen.`,
+	  }) => `Accessibility modifier already seen: '${modifier}'.`,
 	  DuplicateModifier: ({
 	    modifier
 	  }) => `Duplicate modifier: '${modifier}'.`,
@@ -10056,6 +10109,7 @@ function requireLib () {
 	  InvalidHeritageClauseType: ({
 	    token
 	  }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
+	  InvalidModifierOnAwaitUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on an await using declaration.`,
 	  InvalidModifierOnTypeMember: ({
 	    modifier
 	  }) => `'${modifier}' modifier cannot appear on a type member.`,
@@ -10065,6 +10119,7 @@ function requireLib () {
 	  InvalidModifierOnTypeParameterPositions: ({
 	    modifier
 	  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
+	  InvalidModifierOnUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on a using declaration.`,
 	  InvalidModifiersOrder: ({
 	    orderedModifiers
 	  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
@@ -10072,7 +10127,7 @@ function requireLib () {
 	  InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
 	  MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
 	  NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
-	  NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
+	  NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
 	  OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
 	  OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
 	  PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
@@ -10103,7 +10158,8 @@ function requireLib () {
 	  UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
 	  UnsupportedSignatureParameterKind: ({
 	    type
-	  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
+	  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
+	  UsingDeclarationInAmbientContext: kind => `'${kind}' declarations are not allowed in ambient contexts.`
 	});
 	function keywordTypeFromName(value) {
 	  switch (value) {
@@ -10179,12 +10235,15 @@ function requireLib () {
 	    }
 	    return this.tsNextTokenOnSameLineAndCanFollowModifier();
 	  }
-	  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
+	  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
 	    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
 	      return undefined;
 	    }
 	    const modifier = this.state.value;
 	    if (allowedModifiers.includes(modifier)) {
+	      if (hasSeenStaticModifier && this.match(106)) {
+	        return undefined;
+	      }
 	      if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
 	        return undefined;
 	      }
@@ -10218,7 +10277,7 @@ function requireLib () {
 	      const {
 	        startLoc
 	      } = this.state;
-	      const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
+	      const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock, modified.static);
 	      if (!modifier) break;
 	      if (tsIsAccessModifier(modifier)) {
 	        if (modified.accessibility) {
@@ -11115,7 +11174,7 @@ function requireLib () {
 	    return this.finishNode(node, "TSConditionalType");
 	  }
 	  isAbstractConstructorSignature() {
-	    return this.isContextual(124) && this.lookahead().type === 77;
+	    return this.isContextual(124) && this.isLookaheadContextual("new");
 	  }
 	  tsParseNonConditionalType() {
 	    if (this.tsIsStartOfFunctionType()) {
@@ -11186,7 +11245,7 @@ function requireLib () {
 	    node.typeAnnotation = this.tsInType(() => {
 	      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
 	      this.expect(29);
-	      if (this.isContextual(114) && this.lookahead().type !== 16) {
+	      if (this.isContextual(114) && this.lookaheadCharCode() !== 46) {
 	        const node = this.startNode();
 	        this.next();
 	        return this.finishNode(node, "TSIntrinsicKeyword");
@@ -11299,7 +11358,7 @@ function requireLib () {
 	      this.tsParseModuleOrNamespaceDeclaration(inner, true);
 	      node.body = inner;
 	    } else {
-	      this.scope.enter(256);
+	      this.scope.enter(1024);
 	      this.prodParam.enter(0);
 	      node.body = this.tsParseModuleBlock();
 	      this.prodParam.exit();
@@ -11321,7 +11380,7 @@ function requireLib () {
 	      this.unexpected();
 	    }
 	    if (this.match(5)) {
-	      this.scope.enter(256);
+	      this.scope.enter(1024);
 	      this.prodParam.enter(0);
 	      node.body = this.tsParseModuleBlock();
 	      this.prodParam.exit();
@@ -11384,51 +11443,65 @@ function requireLib () {
 	    }
 	    this.state = state;
 	  }
-	  tsTryParseDeclare(nany) {
+	  tsTryParseDeclare(node) {
 	    if (this.isLineTerminator()) {
 	      return;
 	    }
-	    let startType = this.state.type;
-	    let kind;
-	    if (this.isContextual(100)) {
-	      startType = 74;
-	      kind = "let";
-	    }
+	    const startType = this.state.type;
 	    return this.tsInAmbientContext(() => {
 	      switch (startType) {
 	        case 68:
-	          nany.declare = true;
-	          return super.parseFunctionStatement(nany, false, false);
+	          node.declare = true;
+	          return super.parseFunctionStatement(node, false, false);
 	        case 80:
-	          nany.declare = true;
-	          return this.parseClass(nany, true, false);
+	          node.declare = true;
+	          return this.parseClass(node, true, false);
 	        case 126:
-	          return this.tsParseEnumDeclaration(nany, {
+	          return this.tsParseEnumDeclaration(node, {
 	            declare: true
 	          });
 	        case 112:
-	          return this.tsParseAmbientExternalModuleDeclaration(nany);
+	          return this.tsParseAmbientExternalModuleDeclaration(node);
+	        case 100:
+	          if (this.state.containsEsc) {
+	            return;
+	          }
 	        case 75:
 	        case 74:
 	          if (!this.match(75) || !this.isLookaheadContextual("enum")) {
-	            nany.declare = true;
-	            return this.parseVarStatement(nany, kind || this.state.value, true);
+	            node.declare = true;
+	            return this.parseVarStatement(node, this.state.value, true);
 	          }
 	          this.expect(75);
-	          return this.tsParseEnumDeclaration(nany, {
+	          return this.tsParseEnumDeclaration(node, {
 	            const: true,
 	            declare: true
 	          });
+	        case 107:
+	          if (this.isUsing()) {
+	            this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare");
+	            node.declare = true;
+	            return this.parseVarStatement(node, "using", true);
+	          }
+	          break;
+	        case 96:
+	          if (this.isAwaitUsing()) {
+	            this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare");
+	            node.declare = true;
+	            this.next();
+	            return this.parseVarStatement(node, "await using", true);
+	          }
+	          break;
 	        case 129:
 	          {
-	            const result = this.tsParseInterfaceDeclaration(nany, {
+	            const result = this.tsParseInterfaceDeclaration(node, {
 	              declare: true
 	            });
 	            if (result) return result;
 	          }
 	        default:
 	          if (tokenIsIdentifier(startType)) {
-	            return this.tsParseDeclaration(nany, this.state.value, true, null);
+	            return this.tsParseDeclaration(node, this.state.value, true, null);
 	          }
 	      }
 	    });
@@ -11448,7 +11521,7 @@ function requireLib () {
 	        }
 	      case "global":
 	        if (this.match(5)) {
-	          this.scope.enter(256);
+	          this.scope.enter(1024);
 	          this.prodParam.enter(0);
 	          const mod = node;
 	          mod.kind = "global";
@@ -11679,7 +11752,7 @@ function requireLib () {
 	        if (!noCalls && this.eat(10)) {
 	          const node = this.startNodeAt(startLoc);
 	          node.callee = base;
-	          node.arguments = this.parseCallExpressionArguments(11);
+	          node.arguments = this.parseCallExpressionArguments();
 	          this.tsCheckForInvalidTypeCasts(node.arguments);
 	          {
 	            node.typeParameters = typeArguments;
@@ -11836,7 +11909,7 @@ function requireLib () {
 	    }
 	  }
 	  isAbstractClass() {
-	    return this.isContextual(124) && this.lookahead().type === 80;
+	    return this.isContextual(124) && this.isLookaheadContextual("class");
 	  }
 	  parseExportDefaultExpression() {
 	    if (this.isAbstractClass()) {
@@ -11857,12 +11930,16 @@ function requireLib () {
 	    } = this.state;
 	    const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
 	    if (!isAmbientContext) return declaration;
+	    if (!node.declare && (kind === "using" || kind === "await using")) {
+	      this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind);
+	      return declaration;
+	    }
 	    for (const {
 	      id,
 	      init
 	    } of declaration.declarations) {
 	      if (!init) continue;
-	      if (kind !== "const" || !!id.typeAnnotation) {
+	      if (kind === "var" || kind === "let" || !!id.typeAnnotation) {
 	        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
 	      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
 	        this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
@@ -12468,7 +12545,7 @@ function requireLib () {
 	    } else if (this.isContextual(129)) {
 	      if (!this.hasFollowingLineBreak()) {
 	        node.abstract = true;
-	        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, node);
+	        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);
 	        return this.tsParseInterfaceDeclaration(node);
 	      }
 	    } else {
@@ -12827,8 +12904,8 @@ function requireLib () {
 	    if (super.chStartsBindingIdentifier(ch, pos)) {
 	      return true;
 	    }
-	    const nextToken = this.lookahead();
-	    if (nextToken.type === 133) {
+	    const next = this.nextTokenStart();
+	    if (this.input.charCodeAt(next) === 37 && this.input.charCodeAt(next + 1) === 37) {
 	      return true;
 	    }
 	    return false;
@@ -13068,6 +13145,9 @@ function requireLib () {
 	  if (pluginsMap.has("optionalChainingAssign") && pluginsMap.get("optionalChainingAssign").version !== "2023-07") {
 	    throw new Error("The 'optionalChainingAssign' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is '2023-07'.");
 	  }
+	  if (pluginsMap.has("discardBinding") && pluginsMap.get("discardBinding").syntaxType !== "void") {
+	    throw new Error("The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'.");
+	  }
 	}
 	const mixinPlugins = {
 	  estree,
@@ -13109,9 +13189,14 @@ function requireLib () {
 	  getExpression() {
 	    this.enterInitialScopes();
 	    this.nextToken();
+	    if (this.match(140)) {
+	      throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);
+	    }
 	    const expr = this.parseExpression();
 	    if (!this.match(140)) {
-	      this.unexpected();
+	      throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, {
+	        unexpected: this.input.codePointAt(this.state.start)
+	      });
 	    }
 	    this.finalizeRemainingComments();
 	    expr.comments = this.comments;
@@ -13198,6 +13283,9 @@ function requireLib () {
 	          this.checkDestructuringPrivate(refExpressionErrors);
 	          refExpressionErrors.privateKeyLoc = null;
 	        }
+	        if (refExpressionErrors.voidPatternLoc != null && refExpressionErrors.voidPatternLoc.index >= startIndex) {
+	          refExpressionErrors.voidPatternLoc = null;
+	        }
 	      } else {
 	        node.left = left;
 	      }
@@ -13526,9 +13614,9 @@ function requireLib () {
 	      node.optional = optional;
 	    }
 	    if (optional) {
-	      node.arguments = this.parseCallExpressionArguments(11);
+	      node.arguments = this.parseCallExpressionArguments();
 	    } else {
-	      node.arguments = this.parseCallExpressionArguments(11, base.type !== "Super", node, refExpressionErrors);
+	      node.arguments = this.parseCallExpressionArguments(base.type !== "Super", node, refExpressionErrors);
 	    }
 	    let finishedNode = this.finishCallExpression(node, optionalChainMember);
 	    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
@@ -13576,17 +13664,17 @@ function requireLib () {
 	    }
 	    return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
 	  }
-	  parseCallExpressionArguments(close, allowPlaceholder, nodeForExtra, refExpressionErrors) {
+	  parseCallExpressionArguments(allowPlaceholder, nodeForExtra, refExpressionErrors) {
 	    const elts = [];
 	    let first = true;
 	    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
 	    this.state.inFSharpPipelineDirectBody = false;
-	    while (!this.eat(close)) {
+	    while (!this.eat(11)) {
 	      if (first) {
 	        first = false;
 	      } else {
 	        this.expect(12);
-	        if (this.match(close)) {
+	        if (this.match(11)) {
 	          if (nodeForExtra) {
 	            this.addTrailingCommaExtraToNode(nodeForExtra);
 	          }
@@ -13594,7 +13682,7 @@ function requireLib () {
 	          break;
 	        }
 	      }
-	      elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));
+	      elts.push(this.parseExprListItem(11, false, refExpressionErrors, allowPlaceholder));
 	    }
 	    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
 	    return elts;
@@ -13632,7 +13720,7 @@ function requireLib () {
 	        node = this.startNode();
 	        this.next();
 	        if (this.match(16)) {
-	          return this.parseImportMetaProperty(node);
+	          return this.parseImportMetaPropertyOrPhaseCall(node);
 	        }
 	        if (this.match(10)) {
 	          if (this.optionFlags & 512) {
@@ -13925,27 +14013,24 @@ function requireLib () {
 	    }
 	    return this.finishNode(node, "MetaProperty");
 	  }
-	  parseImportMetaProperty(node) {
-	    const id = this.createIdentifier(this.startNodeAtNode(node), "import");
+	  parseImportMetaPropertyOrPhaseCall(node) {
 	    this.next();
-	    if (this.isContextual(101)) {
-	      if (!this.inModule) {
-	        this.raise(Errors.ImportMetaOutsideModule, id);
-	      }
-	      this.sawUnambiguousESM = true;
-	    } else if (this.isContextual(105) || this.isContextual(97)) {
+	    if (this.isContextual(105) || this.isContextual(97)) {
 	      const isSource = this.isContextual(105);
 	      this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
-	      if (!(this.optionFlags & 512)) {
-	        throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, this.state.startLoc, {
-	          phase: this.state.value
-	        });
-	      }
 	      this.next();
 	      node.phase = isSource ? "source" : "defer";
 	      return this.parseImportCall(node);
+	    } else {
+	      const id = this.createIdentifierAt(this.startNodeAtNode(node), "import", this.state.lastTokStartLoc);
+	      if (this.isContextual(101)) {
+	        if (!this.inModule) {
+	          this.raise(Errors.ImportMetaOutsideModule, id);
+	        }
+	        this.sawUnambiguousESM = true;
+	      }
+	      return this.parseMetaProperty(node, id, "meta");
 	    }
-	    return this.parseMetaProperty(node, id, "meta");
 	  }
 	  parseLiteralAtNode(value, type, node) {
 	    this.addExtra(node, "rawValue", value);
@@ -13965,7 +14050,9 @@ function requireLib () {
 	    return this.parseLiteral(value, "NumericLiteral");
 	  }
 	  parseBigIntLiteral(value) {
-	    return this.parseLiteral(value, "BigIntLiteral");
+	    {
+	      return this.parseLiteral(value, "BigIntLiteral");
+	    }
 	  }
 	  parseDecimalLiteral(value) {
 	    return this.parseLiteral(value, "DecimalLiteral");
@@ -14022,7 +14109,7 @@ function requireLib () {
 	          break;
 	        }
 	      } else {
-	        exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
+	        exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(11, refExpressionErrors, this.parseParenItem));
 	      }
 	    }
 	    const innerEndLoc = this.state.lastTokEndLoc;
@@ -14084,7 +14171,7 @@ function requireLib () {
 	      const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
 	      this.next();
 	      const metaProp = this.parseMetaProperty(node, meta, "target");
-	      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !(this.optionFlags & 4)) {
+	      if (!this.scope.allowNewTarget) {
 	        this.raise(Errors.UnexpectedNewTarget, metaProp);
 	      }
 	      return metaProp;
@@ -14299,7 +14386,7 @@ function requireLib () {
 	  parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
 	    prop.shorthand = false;
 	    if (this.eat(14)) {
-	      prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
+	      prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, refExpressionErrors);
 	      return this.finishObjectProperty(prop);
 	    }
 	    if (!prop.computed && prop.key.type === "Identifier") {
@@ -14390,7 +14477,7 @@ function requireLib () {
 	  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
 	    this.initFunction(node, isAsync);
 	    node.generator = isGenerator;
-	    this.scope.enter(2 | 16 | (inClassScope ? 64 : 0) | (allowDirectSuper ? 32 : 0));
+	    this.scope.enter(514 | 16 | (inClassScope ? 576 : 0) | (allowDirectSuper ? 32 : 0));
 	    this.prodParam.enter(functionFlags(isAsync, node.generator));
 	    this.parseFunctionParams(node, isConstructor);
 	    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
@@ -14411,7 +14498,7 @@ function requireLib () {
 	    return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
 	  }
 	  parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
-	    this.scope.enter(2 | 4);
+	    this.scope.enter(514 | 4);
 	    let flags = functionFlags(isAsync, false);
 	    if (!this.match(5) && this.prodParam.hasIn) {
 	      flags |= 8;
@@ -14499,11 +14586,11 @@ function requireLib () {
 	          break;
 	        }
 	      }
-	      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
+	      elts.push(this.parseExprListItem(close, allowEmpty, refExpressionErrors));
 	    }
 	    return elts;
 	  }
-	  parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {
+	  parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) {
 	    let elt;
 	    if (this.match(12)) {
 	      if (!allowEmpty) {
@@ -14524,7 +14611,7 @@ function requireLib () {
 	      this.next();
 	      elt = this.finishNode(node, "ArgumentPlaceholder");
 	    } else {
-	      elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);
+	      elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, this.parseParenItem);
 	    }
 	    return elt;
 	  }
@@ -14538,6 +14625,11 @@ function requireLib () {
 	    node.loc.identifierName = name;
 	    return this.finishNode(node, "Identifier");
 	  }
+	  createIdentifierAt(node, name, endLoc) {
+	    node.name = name;
+	    node.loc.identifierName = name;
+	    return this.finishNodeAt(node, "Identifier", endLoc);
+	  }
 	  parseIdentifierName(liberal) {
 	    let name;
 	    const {
@@ -14602,7 +14694,7 @@ function requireLib () {
 	    }
 	  }
 	  recordAwaitIfAllowed() {
-	    const isAwaitAllowed = this.prodParam.hasAwait || this.optionFlags & 1 && !this.scope.inFunction;
+	    const isAwaitAllowed = this.prodParam.hasAwait;
 	    if (isAwaitAllowed && !this.scope.inFunction) {
 	      this.state.hasTopLevelAwait = true;
 	    }
@@ -14665,12 +14757,17 @@ function requireLib () {
 	    if (this.eat(12)) {
 	      if (!this.match(11)) {
 	        node.options = this.parseMaybeAssignAllowIn();
-	        if (this.eat(12) && !this.match(11)) {
-	          do {
-	            this.parseMaybeAssignAllowIn();
-	          } while (this.eat(12) && !this.match(11));
-	          this.raise(Errors.ImportCallArity, node);
+	        if (this.eat(12)) {
+	          this.addTrailingCommaExtraToNode(node.options);
+	          if (!this.match(11)) {
+	            do {
+	              this.parseMaybeAssignAllowIn();
+	            } while (this.eat(12) && !this.match(11));
+	            this.raise(Errors.ImportCallArity, node);
+	          }
 	        }
+	      } else {
+	        this.addTrailingCommaExtraToNode(node.source);
 	      }
 	    }
 	    this.expect(11);
@@ -14816,6 +14913,24 @@ function requireLib () {
 	    }
 	    return this.finishNode(node, "ModuleExpression");
 	  }
+	  parseVoidPattern(refExpressionErrors) {
+	    this.expectPlugin("discardBinding");
+	    const node = this.startNode();
+	    if (refExpressionErrors != null) {
+	      refExpressionErrors.voidPatternLoc = this.state.startLoc;
+	    }
+	    this.next();
+	    return this.finishNode(node, "VoidPattern");
+	  }
+	  parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) {
+	    if (refExpressionErrors != null && this.match(88)) {
+	      const nextCode = this.lookaheadCharCode();
+	      if (nextCode === 44 || nextCode === (close === 3 ? 93 : close === 8 ? 125 : 41) || nextCode === 61) {
+	        return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors));
+	      }
+	    }
+	    return this.parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse);
+	  }
 	  parsePropertyNamePrefixOperator(prop) {}
 	}
 	const loopLabel = {
@@ -14935,14 +15050,14 @@ function requireLib () {
 	}
 	class StatementParser extends ExpressionParser {
 	  parseTopLevel(file, program) {
-	    file.program = this.parseProgram(program);
+	    file.program = this.parseProgram(program, 140, this.options.sourceType === "module" ? "module" : "script");
 	    file.comments = this.comments;
 	    if (this.optionFlags & 256) {
 	      file.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex);
 	    }
 	    return this.finishNode(file, "File");
 	  }
-	  parseProgram(program, end = 140, sourceType = this.options.sourceType) {
+	  parseProgram(program, end, sourceType) {
 	    program.sourceType = sourceType;
 	    program.interpreter = this.parseInterpreterDirective();
 	    this.parseBlockBody(program, true, true, end);
@@ -14992,6 +15107,45 @@ function requireLib () {
 	    }
 	    return this.hasFollowingBindingAtom();
 	  }
+	  isUsing() {
+	    if (!this.isContextual(107)) {
+	      return false;
+	    }
+	    const next = this.nextTokenInLineStart();
+	    const nextCh = this.codePointAtPos(next);
+	    return this.chStartsBindingIdentifier(nextCh, next);
+	  }
+	  isForUsing() {
+	    if (!this.isContextual(107)) {
+	      return false;
+	    }
+	    const next = this.nextTokenInLineStart();
+	    const nextCh = this.codePointAtPos(next);
+	    if (this.isUnparsedContextual(next, "of")) {
+	      const nextCharAfterOf = this.lookaheadCharCodeSince(next + 2);
+	      if (nextCharAfterOf !== 61 && nextCharAfterOf !== 58 && nextCharAfterOf !== 59) {
+	        return false;
+	      }
+	    }
+	    if (this.chStartsBindingIdentifier(nextCh, next) || this.isUnparsedContextual(next, "void")) {
+	      return true;
+	    }
+	    return false;
+	  }
+	  isAwaitUsing() {
+	    if (!this.isContextual(96)) {
+	      return false;
+	    }
+	    let next = this.nextTokenInLineStart();
+	    if (this.isUnparsedContextual(next, "using")) {
+	      next = this.nextTokenInLineStartSince(next + 5);
+	      const nextCh = this.codePointAtPos(next);
+	      if (this.chStartsBindingIdentifier(nextCh, next)) {
+	        return true;
+	      }
+	    }
+	    return false;
+	  }
 	  chStartsBindingIdentifier(ch, pos) {
 	    if (isIdentifierStart(ch)) {
 	      keywordRelationalOperator.lastIndex = pos;
@@ -15021,35 +15175,8 @@ function requireLib () {
 	    const nextCh = this.codePointAtPos(next);
 	    return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next);
 	  }
-	  allowsForUsing() {
-	    const {
-	      type,
-	      containsEsc,
-	      end
-	    } = this.lookahead();
-	    if (type === 102 && !containsEsc) {
-	      const nextCharAfterOf = this.lookaheadCharCodeSince(end);
-	      if (nextCharAfterOf !== 61 && nextCharAfterOf !== 58 && nextCharAfterOf !== 59) {
-	        return false;
-	      }
-	    }
-	    if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {
-	      this.expectPlugin("explicitResourceManagement");
-	      return true;
-	    }
-	    return false;
-	  }
-	  startsAwaitUsing() {
-	    let next = this.nextTokenInLineStart();
-	    if (this.isUnparsedContextual(next, "using")) {
-	      next = this.nextTokenInLineStartSince(next + 5);
-	      const nextCh = this.codePointAtPos(next);
-	      if (this.chStartsBindingIdentifier(nextCh, next)) {
-	        this.expectPlugin("explicitResourceManagement");
-	        return true;
-	      }
-	    }
-	    return false;
+	  allowsUsing() {
+	    return (this.scope.inModule || !this.scope.inTopLevel) && !this.scope.inBareCaseStatement;
 	  }
 	  parseModuleItem() {
 	    return this.parseStatementLike(1 | 2 | 4 | 8);
@@ -15114,11 +15241,13 @@ function requireLib () {
 	      case 73:
 	        return this.parseTryStatement(node);
 	      case 96:
-	        if (!this.state.containsEsc && this.startsAwaitUsing()) {
-	          if (!this.recordAwaitIfAllowed()) {
-	            this.raise(Errors.AwaitUsingNotInAsyncContext, node);
+	        if (this.isAwaitUsing()) {
+	          if (!this.allowsUsing()) {
+	            this.raise(Errors.UnexpectedUsingDeclaration, node);
 	          } else if (!allowDeclaration) {
 	            this.raise(Errors.UnexpectedLexicalDeclaration, node);
+	          } else if (!this.recordAwaitIfAllowed()) {
+	            this.raise(Errors.AwaitUsingNotInAsyncContext, node);
 	          }
 	          this.next();
 	          return this.parseVarStatement(node, "await using");
@@ -15128,8 +15257,7 @@ function requireLib () {
 	        if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) {
 	          break;
 	        }
-	        this.expectPlugin("explicitResourceManagement");
-	        if (!this.scope.inModule && this.scope.inTopLevel) {
+	        if (!this.allowsUsing()) {
 	          this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);
 	        } else if (!allowDeclaration) {
 	          this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
@@ -15297,7 +15425,7 @@ function requireLib () {
 	    if (this.eat(10)) {
 	      const node = this.startNodeAt(startLoc);
 	      node.callee = expr;
-	      node.arguments = this.parseCallExpressionArguments(11);
+	      node.arguments = this.parseCallExpressionArguments();
 	      this.toReferencedList(node.arguments);
 	      return this.finishNode(node, "CallExpression");
 	    }
@@ -15371,8 +15499,8 @@ function requireLib () {
 	    }
 	    const startsWithLet = this.isContextual(100);
 	    {
-	      const startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
-	      const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(107) && this.allowsForUsing();
+	      const startsWithAwaitUsing = this.isAwaitUsing();
+	      const starsWithUsingDeclaration = startsWithAwaitUsing || this.isForUsing();
 	      const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
 	      if (this.match(74) || this.match(75) || isLetOrUsing) {
 	        const initNode = this.startNode();
@@ -15442,7 +15570,7 @@ function requireLib () {
 	    return this.finishNode(node, "IfStatement");
 	  }
 	  parseReturnStatement(node) {
-	    if (!this.prodParam.hasReturn && !(this.optionFlags & 2)) {
+	    if (!this.prodParam.hasReturn) {
 	      this.raise(Errors.IllegalReturn, this.state.startLoc);
 	    }
 	    this.next();
@@ -15460,7 +15588,7 @@ function requireLib () {
 	    const cases = node.cases = [];
 	    this.expect(5);
 	    this.state.labels.push(switchLabel);
-	    this.scope.enter(0);
+	    this.scope.enter(256);
 	    let cur;
 	    for (let sawDefault; !this.match(8);) {
 	      if (this.match(61) || this.match(65)) {
@@ -15714,6 +15842,10 @@ function requireLib () {
 	      if (id.type === "ArrayPattern" || id.type === "ObjectPattern") {
 	        this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start);
 	      }
+	    } else {
+	      if (id.type === "VoidPattern") {
+	        this.raise(Errors.UnexpectedVoidPattern, id.loc.start);
+	      }
 	    }
 	    this.checkLVal(id, {
 	      type: "VariableDeclarator"
@@ -15741,7 +15873,7 @@ function requireLib () {
 	    }
 	    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
 	    this.state.maybeInArrowParameters = false;
-	    this.scope.enter(2);
+	    this.scope.enter(514);
 	    this.prodParam.enter(functionFlags(isAsync, node.generator));
 	    if (!isDeclaration) {
 	      node.id = this.parseFunctionId();
@@ -15882,6 +16014,7 @@ function requireLib () {
 	      method.kind = "method";
 	      const isPrivateName = this.match(139);
 	      this.parseClassElementName(method);
+	      this.parsePostMemberNameModifiers(method);
 	      if (isPrivateName) {
 	        this.pushClassPrivateMethod(classBody, privateMethod, true, false);
 	        return;
@@ -15993,7 +16126,7 @@ function requireLib () {
 	  }
 	  parseClassStaticBlock(classBody, member) {
 	    var _member$decorators;
-	    this.scope.enter(64 | 128 | 16);
+	    this.scope.enter(576 | 128 | 16);
 	    const oldLabels = this.state.labels;
 	    this.state.labels = [];
 	    this.prodParam.enter(0);
@@ -16057,7 +16190,7 @@ function requireLib () {
 	    return this.finishNode(node, "ClassAccessorProperty");
 	  }
 	  parseInitializer(node) {
-	    this.scope.enter(64 | 16);
+	    this.scope.enter(576 | 16);
 	    this.expressionScope.enter(newExpressionScope());
 	    this.prodParam.enter(0);
 	    node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
@@ -16224,7 +16357,7 @@ function requireLib () {
 	      }
 	      return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
 	    }
-	    if (this.match(75) || this.match(74) || this.isLet()) {
+	    if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) {
 	      throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
 	    }
 	    const res = this.parseMaybeAssignAllowIn();
@@ -16247,10 +16380,9 @@ function requireLib () {
 	        return false;
 	      }
 	      if ((type === 130 || type === 129) && !this.state.containsEsc) {
-	        const {
-	          type: nextType
-	        } = this.lookahead();
-	        if (tokenIsIdentifier(nextType) && nextType !== 98 || nextType === 5) {
+	        const next = this.nextTokenStart();
+	        const nextChar = this.input.charCodeAt(next);
+	        if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.input.startsWith("from", next)) {
 	          this.expectOnePlugin(["flow", "typescript"]);
 	          return false;
 	        }
@@ -16293,11 +16425,11 @@ function requireLib () {
 	        return true;
 	      }
 	    }
-	    if (this.isContextual(107)) {
+	    if (this.isUsing()) {
 	      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
 	      return true;
 	    }
-	    if (this.isContextual(96) && this.startsAwaitUsing()) {
+	    if (this.isAwaitUsing()) {
 	      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
 	      return true;
 	    }
@@ -16514,18 +16646,18 @@ function requireLib () {
 	      this.applyImportPhase(node, isExport, null);
 	      return null;
 	    }
-	    const phaseIdentifier = this.parseIdentifier(true);
+	    const phaseIdentifier = this.startNode();
+	    const phaseIdentifierName = this.parseIdentifierName(true);
 	    const {
 	      type
 	    } = this.state;
 	    const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
 	    if (isImportPhase) {
-	      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
-	      this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
+	      this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);
 	      return null;
 	    } else {
 	      this.applyImportPhase(node, isExport, null);
-	      return phaseIdentifier;
+	      return this.createIdentifier(phaseIdentifier, phaseIdentifierName);
 	    }
 	  }
 	  isPrecedingIdImportPhase(phase) {
@@ -17162,14 +17294,15 @@ function isReferencedIdentifier(id, parent, parentStack) {
   if (id.name === "arguments") {
     return false;
   }
-  if (isReferenced(id, parent)) {
+  if (isReferenced(id, parent, parentStack[parentStack.length - 2])) {
     return true;
   }
   switch (parent.type) {
     case "AssignmentExpression":
     case "AssignmentPattern":
       return true;
-    case "ObjectPattern":
+    case "ObjectProperty":
+      return parent.key !== id && isInDestructureAssignment(parent, parentStack);
     case "ArrayPattern":
       return isInDestructureAssignment(parent, parentStack);
   }
@@ -17338,7 +17471,7 @@ function isReferenced(node, parent, grandparent) {
       if (parent.key === node) {
         return !!parent.computed;
       }
-      return true;
+      return !grandparent || grandparent.type !== "ObjectPattern";
     // no: class { NODE = value; }
     // yes: class { [NODE] = value; }
     // yes: class { key = NODE; }
@@ -17388,6 +17521,9 @@ function isReferenced(node, parent, grandparent) {
     // yes: export { NODE as foo };
     // no: export { NODE as foo } from "foo";
     case "ExportSpecifier":
+      if (grandparent == null ? void 0 : grandparent.source) {
+        return false;
+      }
       return parent.local === node;
     // no: import NODE from "foo";
     // no: import * as NODE from "foo";
@@ -17468,7 +17604,7 @@ function isCoreComponent(tag) {
       return BASE_TRANSITION;
   }
 }
-const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
+const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
 const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
 const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
 const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
@@ -17633,6 +17769,9 @@ function hasDynamicKeyVBind(node) {
 function isText$1(node) {
   return node.type === 5 || node.type === 2;
 }
+function isVPre(p) {
+  return p.type === 7 && p.name === "pre";
+}
 function isVSlot(p) {
   return p.type === 7 && p.name === "slot";
 }
@@ -17931,7 +18070,7 @@ const tokenizer = new Tokenizer(stack, {
   ondirarg(start, end) {
     if (start === end) return;
     const arg = getSlice(start, end);
-    if (inVPre) {
+    if (inVPre && !isVPre(currentProp)) {
       currentProp.name += arg;
       setLocEnd(currentProp.nameLoc, end);
     } else {
@@ -17946,7 +18085,7 @@ const tokenizer = new Tokenizer(stack, {
   },
   ondirmodifier(start, end) {
     const mod = getSlice(start, end);
-    if (inVPre) {
+    if (inVPre && !isVPre(currentProp)) {
       currentProp.name += "." + mod;
       setLocEnd(currentProp.nameLoc, end);
     } else if (currentProp.name === "slot") {
@@ -18286,7 +18425,7 @@ function isUpperCase(c) {
   return c > 64 && c < 91;
 }
 const windowsNewlineRE = /\r\n/g;
-function condenseWhitespace(nodes, tag) {
+function condenseWhitespace(nodes) {
   const shouldCondense = currentOptions.whitespace !== "preserve";
   let removedWhitespace = false;
   for (let i = 0; i < nodes.length; i++) {
@@ -18472,12 +18611,12 @@ function cacheStatic(root, context) {
     context,
     // Root node is unfortunately non-hoistable due to potential parent
     // fallthrough attributes.
-    isSingleElementRoot(root, root.children[0])
+    !!getSingleElementRoot(root)
   );
 }
-function isSingleElementRoot(root, child) {
-  const { children } = root;
-  return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
+function getSingleElementRoot(root) {
+  const children = root.children.filter((x) => x.type !== 3);
+  return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;
 }
 function walk$1(node, parent, context, doNotHoistNode = false, inFor = false) {
   const { children } = node;
@@ -18510,6 +18649,11 @@ function walk$1(node, parent, context, doNotHoistNode = false, inFor = false) {
     } else if (child.type === 12) {
       const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
       if (constantType >= 2) {
+        if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) {
+          child.codegenNode.arguments.push(
+            -1 + (` /* ${PatchFlagNames[-1]} */` )
+          );
+        }
         toCache.push(child);
         continue;
       }
@@ -18965,15 +19109,15 @@ function createRootCodegen(root, context) {
   const { helper } = context;
   const { children } = root;
   if (children.length === 1) {
-    const child = children[0];
-    if (isSingleElementRoot(root, child) && child.codegenNode) {
-      const codegenNode = child.codegenNode;
+    const singleElementRootChild = getSingleElementRoot(root);
+    if (singleElementRootChild && singleElementRootChild.codegenNode) {
+      const codegenNode = singleElementRootChild.codegenNode;
       if (codegenNode.type === 13) {
         convertToBlock(codegenNode, context);
       }
       root.codegenNode = codegenNode;
     } else {
-      root.codegenNode = child;
+      root.codegenNode = children[0];
     }
   } else if (children.length > 1) {
     let patchFlag = 64;
@@ -23756,7 +23900,7 @@ const transformBind = (dir, _node, context) => {
     arg.children.unshift(`(`);
     arg.children.push(`) || ""`);
   } else if (!arg.isStatic) {
-    arg.content = `${arg.content} || ""`;
+    arg.content = arg.content ? `${arg.content} || ""` : `""`;
   }
   if (modifiers.some((mod) => mod.content === "camel")) {
     if (arg.type === 4) {
@@ -24169,7 +24313,7 @@ function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
       let prev;
       while (j--) {
         prev = children[j];
-        if (prev.type !== 3) {
+        if (prev.type !== 3 && isNonWhitespaceContent(prev)) {
           break;
         }
       }
@@ -26397,6 +26541,7 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   isStaticPropertyKey: isStaticPropertyKey,
   isTemplateNode: isTemplateNode,
   isText: isText$1,
+  isVPre: isVPre,
   isVSlot: isVSlot,
   locStub: locStub,
   noopDirectiveTransform: noopDirectiveTransform,
@@ -26511,7 +26656,14 @@ const CSS_VARS_HELPER = `useCssVars`;
 function genCssVarsFromList(vars, id, isProd, isSSR = false) {
   return `{
   ${vars.map(
-    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
+    (key) => (
+      // The `:` prefix here is used in `ssrRenderStyle` to distinguish whether
+      // a custom property comes from `ssrCssVars`. If it does, we need to reset
+      // its value to `initial` on the component instance to avoid unintentionally
+      // inheriting the same property value from a different instance of the same
+      // component in the outer scope.
+      `"${isSSR ? `:--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
+    )
   ).join(",\n  ")}
 }`;
 }
@@ -31562,7 +31714,7 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
             }
           }
           const shouldProcessUrl = (url) => {
-            return !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
+            return url && !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
           };
           if (!imageCandidates.some(({ url }) => shouldProcessUrl(url))) {
             return;
@@ -32740,6 +32892,17 @@ const ssrTransformModel = (dir, node, context) => {
       );
     }
   }
+  const processSelectChildren = (children) => {
+    children.forEach((child) => {
+      if (child.type === 1) {
+        processOption(child);
+      } else if (child.type === 11) {
+        processSelectChildren(child.children);
+      } else if (child.type === 9) {
+        child.branches.forEach((b) => processSelectChildren(b.children));
+      }
+    });
+  };
   function processOption(plainNode) {
     if (plainNode.tag === "option") {
       if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
@@ -32766,9 +32929,7 @@ const ssrTransformModel = (dir, node, context) => {
         );
       }
     } else if (plainNode.tag === "optgroup") {
-      plainNode.children.forEach(
-        (option) => processOption(option)
-      );
+      processSelectChildren(plainNode.children);
     }
   }
   if (node.tagType === 0) {
@@ -32853,18 +33014,7 @@ const ssrTransformModel = (dir, node, context) => {
       checkDuplicatedValue();
       node.children = [createInterpolation(model, model.loc)];
     } else if (node.tag === "select") {
-      const processChildren = (children) => {
-        children.forEach((child) => {
-          if (child.type === 1) {
-            processOption(child);
-          } else if (child.type === 11) {
-            processChildren(child.children);
-          } else if (child.type === 9) {
-            child.branches.forEach((b) => processChildren(b.children));
-          }
-        });
-      };
-      processChildren(node.children);
+      processSelectChildren(node.children);
     } else {
       context.onError(
         createDOMCompilerError(
@@ -34340,11 +34490,8 @@ function requireNode$2 () {
 
 	function sourceOffset(inputCSS, position) {
 	  // Not all custom syntaxes support `offset` in `source.start` and `source.end`
-	  if (
-	    position &&
-	    typeof position.offset !== 'undefined'
-	  ) {
-	    return position.offset;
+	  if (position && typeof position.offset !== 'undefined') {
+	    return position.offset
 	  }
 
 	  let column = 1;
@@ -34514,14 +34661,15 @@ function requireNode$2 () {
 	    return this.parent.nodes[index + 1]
 	  }
 
-	  positionBy(opts) {
+	  positionBy(opts = {}) {
 	    let pos = this.source.start;
 	    if (opts.index) {
 	      pos = this.positionInside(opts.index);
 	    } else if (opts.word) {
-	      let inputString = ('document' in this.source.input)
-	        ? this.source.input.document
-	        : this.source.input.css;
+	      let inputString =
+	        'document' in this.source.input
+	          ? this.source.input.document
+	          : this.source.input.css;
 	      let stringRepresentation = inputString.slice(
 	        sourceOffset(inputString, this.source.start),
 	        sourceOffset(inputString, this.source.end)
@@ -34535,9 +34683,10 @@ function requireNode$2 () {
 	  positionInside(index) {
 	    let column = this.source.start.column;
 	    let line = this.source.start.line;
-	    let inputString = ('document' in this.source.input)
-	      ? this.source.input.document
-	      : this.source.input.css;
+	    let inputString =
+	      'document' in this.source.input
+	        ? this.source.input.document
+	        : this.source.input.css;
 	    let offset = sourceOffset(inputString, this.source.start);
 	    let end = offset + index;
 
@@ -34550,7 +34699,7 @@ function requireNode$2 () {
 	      }
 	    }
 
-	    return { column, line }
+	    return { column, line, offset: end }
 	  }
 
 	  prev() {
@@ -34559,25 +34708,36 @@ function requireNode$2 () {
 	    return this.parent.nodes[index - 1]
 	  }
 
-	  rangeBy(opts) {
+	  rangeBy(opts = {}) {
+	    let inputString =
+	      'document' in this.source.input
+	        ? this.source.input.document
+	        : this.source.input.css;
 	    let start = {
 	      column: this.source.start.column,
-	      line: this.source.start.line
+	      line: this.source.start.line,
+	      offset: sourceOffset(inputString, this.source.start)
 	    };
 	    let end = this.source.end
 	      ? {
 	          column: this.source.end.column + 1,
-	          line: this.source.end.line
+	          line: this.source.end.line,
+	          offset:
+	            typeof this.source.end.offset === 'number'
+	              ? // `source.end.offset` is exclusive, so we don't need to add 1
+	                this.source.end.offset
+	              : // Since line/column in this.source.end is inclusive,
+	                // the `sourceOffset(... , this.source.end)` returns an inclusive offset.
+	                // So, we add 1 to convert it to exclusive.
+	                sourceOffset(inputString, this.source.end) + 1
 	        }
 	      : {
 	          column: start.column + 1,
-	          line: start.line
+	          line: start.line,
+	          offset: start.offset + 1
 	        };
 
 	    if (opts.word) {
-	      let inputString = ('document' in this.source.input)
-	        ? this.source.input.document
-	        : this.source.input.css;
 	      let stringRepresentation = inputString.slice(
 	        sourceOffset(inputString, this.source.start),
 	        sourceOffset(inputString, this.source.end)
@@ -34585,15 +34745,14 @@ function requireNode$2 () {
 	      let index = stringRepresentation.indexOf(opts.word);
 	      if (index !== -1) {
 	        start = this.positionInside(index);
-	        end = this.positionInside(
-	          index + opts.word.length,
-	        );
+	        end = this.positionInside(index + opts.word.length);
 	      }
 	    } else {
 	      if (opts.start) {
 	        start = {
 	          column: opts.start.column,
-	          line: opts.start.line
+	          line: opts.start.line,
+	          offset: sourceOffset(inputString, opts.start)
 	        };
 	      } else if (opts.index) {
 	        start = this.positionInside(opts.index);
@@ -34602,7 +34761,8 @@ function requireNode$2 () {
 	      if (opts.end) {
 	        end = {
 	          column: opts.end.column,
-	          line: opts.end.line
+	          line: opts.end.line,
+	          offset: sourceOffset(inputString, opts.end)
 	        };
 	      } else if (typeof opts.endIndex === 'number') {
 	        end = this.positionInside(opts.endIndex);
@@ -34615,7 +34775,11 @@ function requireNode$2 () {
 	      end.line < start.line ||
 	      (end.line === start.line && end.column <= start.column)
 	    ) {
-	      end = { column: start.column + 1, line: start.line };
+	      end = {
+	        column: start.column + 1,
+	        line: start.line,
+	        offset: start.offset + 1
+	      };
 	    }
 
 	    return { end, start }
@@ -34690,6 +34854,7 @@ function requireNode$2 () {
 	      } else if (typeof value === 'object' && value.toJSON) {
 	        fixed[name] = value.toJSON(null, inputs);
 	      } else if (name === 'source') {
+	        if (value == null) continue
 	        let inputId = inputs.get(value.input);
 	        if (inputId == null) {
 	          inputId = inputsNextIndex;
@@ -34729,7 +34894,7 @@ function requireNode$2 () {
 	    return result
 	  }
 
-	  warn(result, text, opts) {
+	  warn(result, text, opts = {}) {
 	    let data = { node: this };
 	    for (let i in opts) data[i] = opts[i];
 	    return result.warn(text, data)
@@ -35536,11 +35701,26 @@ function requireInput () {
 	let PreviousMap = /*@__PURE__*/ requirePreviousMap();
 	let terminalHighlight = /*@__PURE__*/ requireTerminalHighlight();
 
-	let fromOffsetCache = Symbol('fromOffsetCache');
+	let lineToIndexCache = Symbol('lineToIndexCache');
 
 	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
 	let pathAvailable = Boolean(resolve && isAbsolute);
 
+	function getLineToIndex(input) {
+	  if (input[lineToIndexCache]) return input[lineToIndexCache]
+	  let lines = input.css.split('\n');
+	  let lineToIndex = new Array(lines.length);
+	  let prevIndex = 0;
+
+	  for (let i = 0, l = lines.length; i < l; i++) {
+	    lineToIndex[i] = prevIndex;
+	    prevIndex += lines[i].length + 1;
+	  }
+
+	  input[lineToIndexCache] = lineToIndex;
+	  return lineToIndex
+	}
+
 	class Input {
 	  get from() {
 	    return this.file || this.id
@@ -35595,31 +35775,38 @@ function requireInput () {
 	  }
 
 	  error(message, line, column, opts = {}) {
-	    let endColumn, endLine, result;
+	    let endColumn, endLine, endOffset, offset, result;
 
 	    if (line && typeof line === 'object') {
 	      let start = line;
 	      let end = column;
 	      if (typeof start.offset === 'number') {
-	        let pos = this.fromOffset(start.offset);
+	        offset = start.offset;
+	        let pos = this.fromOffset(offset);
 	        line = pos.line;
 	        column = pos.col;
 	      } else {
 	        line = start.line;
 	        column = start.column;
+	        offset = this.fromLineAndColumn(line, column);
 	      }
 	      if (typeof end.offset === 'number') {
-	        let pos = this.fromOffset(end.offset);
+	        endOffset = end.offset;
+	        let pos = this.fromOffset(endOffset);
 	        endLine = pos.line;
 	        endColumn = pos.col;
 	      } else {
 	        endLine = end.line;
 	        endColumn = end.column;
+	        endOffset = this.fromLineAndColumn(end.line, end.column);
 	      }
 	    } else if (!column) {
-	      let pos = this.fromOffset(line);
+	      offset = line;
+	      let pos = this.fromOffset(offset);
 	      line = pos.line;
 	      column = pos.col;
+	    } else {
+	      offset = this.fromLineAndColumn(line, column);
 	    }
 
 	    let origin = this.origin(line, column, endLine, endColumn);
@@ -35647,7 +35834,7 @@ function requireInput () {
 	      );
 	    }
 
-	    result.input = { column, endColumn, endLine, line, source: this.css };
+	    result.input = { column, endColumn, endLine, endOffset, line, offset, source: this.css };
 	    if (this.file) {
 	      if (pathToFileURL) {
 	        result.input.url = pathToFileURL(this.file).toString();
@@ -35658,23 +35845,15 @@ function requireInput () {
 	    return result
 	  }
 
-	  fromOffset(offset) {
-	    let lastLine, lineToIndex;
-	    if (!this[fromOffsetCache]) {
-	      let lines = this.css.split('\n');
-	      lineToIndex = new Array(lines.length);
-	      let prevIndex = 0;
-
-	      for (let i = 0, l = lines.length; i < l; i++) {
-	        lineToIndex[i] = prevIndex;
-	        prevIndex += lines[i].length + 1;
-	      }
+	  fromLineAndColumn(line, column) {
+	    let lineToIndex = getLineToIndex(this);
+	    let index = lineToIndex[line - 1];
+	    return index + column - 1
+	  }
 
-	      this[fromOffsetCache] = lineToIndex;
-	    } else {
-	      lineToIndex = this[fromOffsetCache];
-	    }
-	    lastLine = lineToIndex[lineToIndex.length - 1];
+	  fromOffset(offset) {
+	    let lineToIndex = getLineToIndex(this);
+	    let lastLine = lineToIndex[lineToIndex.length - 1];
 
 	    let min = 0;
 	    if (offset >= lastLine) {
@@ -37120,7 +37299,7 @@ function requireResult () {
 	    this.messages = [];
 	    this.root = root;
 	    this.opts = opts;
-	    this.css = undefined;
+	    this.css = '';
 	    this.map = undefined;
 	  }
 
@@ -37891,7 +38070,7 @@ function requireProcessor$1 () {
 
 	class Processor {
 	  constructor(plugins = []) {
-	    this.version = '8.5.3';
+	    this.version = '8.5.6';
 	    this.plugins = this.normalize(plugins);
 	  }
 
@@ -41731,6 +41910,7 @@ var selectorParser = /*@__PURE__*/getDefaultExportFromCjs(distExports);
 
 const animationNameRE = /^(-\w+-)?animation-name$/;
 const animationRE = /^(-\w+-)?animation$/;
+const keyframesRE = /^(?:-\w+-)?keyframes$/;
 const scopedPlugin = (id = "") => {
   const keyframes = /* @__PURE__ */ Object.create(null);
   const shortId = id.replace(/^data-v-/, "");
@@ -41740,7 +41920,7 @@ const scopedPlugin = (id = "") => {
       processRule(id, rule);
     },
     AtRule(node) {
-      if (/-?keyframes$/.test(node.name) && !node.params.endsWith(`-${shortId}`)) {
+      if (keyframesRE.test(node.name) && !node.params.endsWith(`-${shortId}`)) {
         keyframes[node.params] = node.params = node.params + "-" + shortId;
       }
     },
@@ -41769,7 +41949,7 @@ const scopedPlugin = (id = "") => {
 };
 const processedRules = /* @__PURE__ */ new WeakSet();
 function processRule(id, rule) {
-  if (processedRules.has(rule) || rule.parent && rule.parent.type === "atrule" && /-?keyframes$/.test(rule.parent.name)) {
+  if (processedRules.has(rule) || rule.parent && rule.parent.type === "atrule" && keyframesRE.test(rule.parent.name)) {
     return;
   }
   processedRules.add(rule);
@@ -47639,25 +47819,39 @@ function resolveArrayElementType(ctx, node, scope) {
     scope
   );
 }
-function resolveStringType(ctx, node, scope) {
+function resolveStringType(ctx, node, scope, typeParameters) {
   switch (node.type) {
     case "StringLiteral":
       return [node.value];
     case "TSLiteralType":
-      return resolveStringType(ctx, node.literal, scope);
+      return resolveStringType(ctx, node.literal, scope, typeParameters);
     case "TSUnionType":
-      return node.types.map((t) => resolveStringType(ctx, t, scope)).flat();
+      return node.types.map((t) => resolveStringType(ctx, t, scope, typeParameters)).flat();
     case "TemplateLiteral": {
       return resolveTemplateKeys(ctx, node, scope);
     }
     case "TSTypeReference": {
       const resolved = resolveTypeReference(ctx, node, scope);
       if (resolved) {
-        return resolveStringType(ctx, resolved, scope);
+        return resolveStringType(ctx, resolved, scope, typeParameters);
       }
       if (node.typeName.type === "Identifier") {
-        const getParam = (index = 0) => resolveStringType(ctx, node.typeParameters.params[index], scope);
-        switch (node.typeName.name) {
+        const name = node.typeName.name;
+        if (typeParameters && typeParameters[name]) {
+          return resolveStringType(
+            ctx,
+            typeParameters[name],
+            scope,
+            typeParameters
+          );
+        }
+        const getParam = (index = 0) => resolveStringType(
+          ctx,
+          node.typeParameters.params[index],
+          scope,
+          typeParameters
+        );
+        switch (name) {
           case "Extract":
             return getParam(1);
           case "Exclude": {
@@ -47743,7 +47937,8 @@ function resolveBuiltin(ctx, node, name, scope, typeParameters) {
       const picked = resolveStringType(
         ctx,
         node.typeParameters.params[1],
-        scope
+        scope,
+        typeParameters
       );
       const res2 = { props: {}, calls: t.calls };
       for (const key of picked) {
@@ -47755,7 +47950,8 @@ function resolveBuiltin(ctx, node, name, scope, typeParameters) {
       const omitted = resolveStringType(
         ctx,
         node.typeParameters.params[1],
-        scope
+        scope,
+        typeParameters
       );
       const res = { props: {}, calls: t.calls };
       for (const key in t.props) {
@@ -48318,13 +48514,8 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       case "TSTypeReference": {
         const resolved = resolveTypeReference(ctx, node, scope);
         if (resolved) {
-          if (resolved.type === "TSTypeAliasDeclaration") {
-            return inferRuntimeType(
-              ctx,
-              resolved.typeAnnotation,
-              resolved._ownerScope,
-              isKeyOf
-            );
+          if (resolved.type === "TSTypeAliasDeclaration" && resolved.typeAnnotation.type === "TSFunctionType") {
+            return ["Function"];
           }
           return inferRuntimeType(ctx, resolved, resolved._ownerScope, isKeyOf);
         }
@@ -50256,7 +50447,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.16";
+const version = "3.5.18";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;