@vue/compiler-sfc 3.5.0-alpha.2 → 3.5.0-alpha.3

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

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.0-alpha.2
+* @vue/compiler-sfc v3.5.0-alpha.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -86,11 +86,14 @@ const slotFlagsText = {
   [3]: "FORWARDED"
 };
 
-const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error";
+const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
 const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
 
 const range = 2;
 function generateCodeFrame(source, start = 0, end = source.length) {
+  start = Math.max(0, Math.min(start, source.length));
+  end = Math.max(0, Math.min(end, source.length));
+  if (start > end) return "";
   let lines = source.split(/(\r?\n)/);
   const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
   lines = lines.filter((_, idx) => idx % 2 === 0);
@@ -100,8 +103,7 @@ function generateCodeFrame(source, start = 0, end = source.length) {
     count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
     if (count >= start) {
       for (let j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length)
-          continue;
+        if (j < 0 || j >= lines.length) continue;
         const line = j + 1;
         res.push(
           `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
@@ -166,8 +168,8 @@ function stringifyStyle(styles) {
   }
   for (const key in styles) {
     const value = styles[key];
-    const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
     if (isString$2(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
       ret += `${normalizedKey}:${value};`;
     }
   }
@@ -272,11 +274,14 @@ function escapeHtml(string) {
   return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
 }
 
+const isRef = (val) => {
+  return !!(val && val["__v_isRef"] === true);
+};
 const toDisplayString = (val) => {
-  return isString$2(val) ? val : val == null ? "" : isArray$3(val) || isObject$2(val) && (val.toString === objectToString$1 || !isFunction$1(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+  return isString$2(val) ? val : val == null ? "" : isArray$3(val) || isObject$2(val) && (val.toString === objectToString$1 || !isFunction$1(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
 };
 const replacer = (_key, val) => {
-  if (val && val.__v_isRef) {
+  if (isRef(val)) {
     return replacer(_key, val.value);
   } else if (isMap(val)) {
     return {
@@ -475,8 +480,8 @@ const ConstantTypes = {
   "0": "NOT_CONSTANT",
   "CAN_SKIP_PATCH": 1,
   "1": "CAN_SKIP_PATCH",
-  "CAN_HOIST": 2,
-  "2": "CAN_HOIST",
+  "CAN_CACHE": 2,
+  "2": "CAN_CACHE",
   "CAN_STRINGIFY": 3,
   "3": "CAN_STRINGIFY"
 };
@@ -495,7 +500,7 @@ function createRoot(children, source = "") {
     directives: [],
     hoists: [],
     imports: [],
-    cached: 0,
+    cached: [],
     temps: 0,
     codegenNode: void 0,
     loc: locStub
@@ -600,12 +605,13 @@ function createConditionalExpression(test, consequent, alternate, newline = true
     loc: locStub
   };
 }
-function createCacheExpression(index, value, isVNode = false) {
+function createCacheExpression(index, value, needPauseTracking = false) {
   return {
     type: 20,
     index,
     value,
-    isVNode,
+    needPauseTracking,
+    needArraySpread: false,
     loc: locStub
   };
 }
@@ -2146,8 +2152,7 @@ function warnDeprecation(key, context, loc, ...args) {
   Details: ${link}` : ``}`;
   const err = new SyntaxError(msg);
   err.code = key;
-  if (loc)
-    err.loc = loc;
+  if (loc) err.loc = loc;
   context.onWarn(err);
 }
 
@@ -2447,10 +2452,7 @@ const NodeDescriptions = {
   VariableDeclarator: "variable declaration",
   YieldExpression: "yield expression"
 };
-const toNodeDescription = ({
-  type,
-  prefix
-}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
+const toNodeDescription = node => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
 var StandardErrors = {
   AccessorIsGenerator: ({
     kind
@@ -2661,6 +2663,7 @@ var StandardErrors = {
   UnterminatedRegExp: "Unterminated regular expression.",
   UnterminatedString: "Unterminated string constant.",
   UnterminatedTemplate: "Unterminated template.",
+  UsingDeclarationExport: "Using declaration cannot be exported.",
   UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
   VarRedeclaration: ({
     identifierName
@@ -2950,6 +2953,10 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     }
     return this.finishNode(node, "MethodDefinition");
   }
+  nameIsConstructor(key) {
+    if (key.type === "Literal") return key.value === "constructor";
+    return super.nameIsConstructor(key);
+  }
   parseClassProperty(...args) {
     const propertyNode = super.parseClassProperty(...args);
     {
@@ -3014,9 +3021,9 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     }
   }
   toAssignableObjectExpressionProp(prop, isLast, isLHS) {
-    if (prop.kind === "get" || prop.kind === "set") {
+    if (prop.type === "Property" && (prop.kind === "get" || prop.kind === "set")) {
       this.raise(Errors.PatternHasAccessor, prop.key);
-    } else if (prop.method) {
+    } else if (prop.type === "Property" && prop.method) {
       this.raise(Errors.PatternHasMethod, prop.key);
     } else {
       super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
@@ -3028,9 +3035,9 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
       node.type = "ImportExpression";
       node.source = node.arguments[0];
       if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
-        var _node$arguments$, _node$arguments$2;
-        node.options = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
-        node.attributes = (_node$arguments$2 = node.arguments[1]) != null ? _node$arguments$2 : null;
+        var _ref, _ref2;
+        node.options = (_ref = node.arguments[1]) != null ? _ref : null;
+        node.attributes = (_ref2 = node.arguments[1]) != null ? _ref2 : null;
       }
       delete node.arguments;
       delete node.callee;
@@ -3102,7 +3109,7 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     return node.type === "Property" && node.kind === "init" && !node.method;
   }
   isObjectMethod(node) {
-    return node.method || node.kind === "get" || node.kind === "set";
+    return node.type === "Property" && (node.method || node.kind === "get" || node.kind === "set");
   }
   finishNodeAt(node, type, endLoc) {
     return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
@@ -4005,7 +4012,9 @@ class CommentsParser extends BaseParser {
     const {
       commentsLen
     } = this.state;
-    if (this.comments.length != commentsLen) this.comments.length = commentsLen;
+    if (this.comments.length !== commentsLen) {
+      this.comments.length = commentsLen;
+    }
     this.comments.push(comment);
     this.state.commentsLen++;
   }
@@ -4227,12 +4236,8 @@ class State {
   get strict() {
     return (this.flags & 1) > 0;
   }
-  set strict(value) {
-    if (value) {
-      this.flags |= 1;
-    } else {
-      this.flags &= ~1;
-    }
+  set strict(v) {
+    if (v) this.flags |= 1;else this.flags &= -2;
   }
   init({
     strictMode,
@@ -4248,112 +4253,68 @@ class State {
   get maybeInArrowParameters() {
     return (this.flags & 2) > 0;
   }
-  set maybeInArrowParameters(value) {
-    if (value) {
-      this.flags |= 2;
-    } else {
-      this.flags &= ~2;
-    }
+  set maybeInArrowParameters(v) {
+    if (v) this.flags |= 2;else this.flags &= -3;
   }
   get inType() {
     return (this.flags & 4) > 0;
   }
-  set inType(value) {
-    if (value) {
-      this.flags |= 4;
-    } else {
-      this.flags &= ~4;
-    }
+  set inType(v) {
+    if (v) this.flags |= 4;else this.flags &= -5;
   }
   get noAnonFunctionType() {
     return (this.flags & 8) > 0;
   }
-  set noAnonFunctionType(value) {
-    if (value) {
-      this.flags |= 8;
-    } else {
-      this.flags &= ~8;
-    }
+  set noAnonFunctionType(v) {
+    if (v) this.flags |= 8;else this.flags &= -9;
   }
   get hasFlowComment() {
     return (this.flags & 16) > 0;
   }
-  set hasFlowComment(value) {
-    if (value) {
-      this.flags |= 16;
-    } else {
-      this.flags &= ~16;
-    }
+  set hasFlowComment(v) {
+    if (v) this.flags |= 16;else this.flags &= -17;
   }
   get isAmbientContext() {
     return (this.flags & 32) > 0;
   }
-  set isAmbientContext(value) {
-    if (value) {
-      this.flags |= 32;
-    } else {
-      this.flags &= ~32;
-    }
+  set isAmbientContext(v) {
+    if (v) this.flags |= 32;else this.flags &= -33;
   }
   get inAbstractClass() {
     return (this.flags & 64) > 0;
   }
-  set inAbstractClass(value) {
-    if (value) {
-      this.flags |= 64;
-    } else {
-      this.flags &= ~64;
-    }
+  set inAbstractClass(v) {
+    if (v) this.flags |= 64;else this.flags &= -65;
   }
   get inDisallowConditionalTypesContext() {
     return (this.flags & 128) > 0;
   }
-  set inDisallowConditionalTypesContext(value) {
-    if (value) {
-      this.flags |= 128;
-    } else {
-      this.flags &= ~128;
-    }
+  set inDisallowConditionalTypesContext(v) {
+    if (v) this.flags |= 128;else this.flags &= -129;
   }
   get soloAwait() {
     return (this.flags & 256) > 0;
   }
-  set soloAwait(value) {
-    if (value) {
-      this.flags |= 256;
-    } else {
-      this.flags &= ~256;
-    }
+  set soloAwait(v) {
+    if (v) this.flags |= 256;else this.flags &= -257;
   }
   get inFSharpPipelineDirectBody() {
     return (this.flags & 512) > 0;
   }
-  set inFSharpPipelineDirectBody(value) {
-    if (value) {
-      this.flags |= 512;
-    } else {
-      this.flags &= ~512;
-    }
+  set inFSharpPipelineDirectBody(v) {
+    if (v) this.flags |= 512;else this.flags &= -513;
   }
   get canStartJSXElement() {
     return (this.flags & 1024) > 0;
   }
-  set canStartJSXElement(value) {
-    if (value) {
-      this.flags |= 1024;
-    } else {
-      this.flags &= ~1024;
-    }
+  set canStartJSXElement(v) {
+    if (v) this.flags |= 1024;else this.flags &= -1025;
   }
   get containsEsc() {
     return (this.flags & 2048) > 0;
   }
-  set containsEsc(value) {
-    if (value) {
-      this.flags |= 2048;
-    } else {
-      this.flags &= ~2048;
-    }
+  set containsEsc(v) {
+    if (v) this.flags |= 2048;else this.flags &= -2049;
   }
   curPosition() {
     return new Position(this.curLine, this.pos - this.lineStart, this.pos);
@@ -7179,50 +7140,56 @@ var flow = superClass => class FlowParserMixin extends superClass {
         this.state.noAnonFunctionType = oldNoAnonFunctionType;
         return type;
       case 47:
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-        this.expect(10);
-        tmp = this.flowParseFunctionTypeParams();
-        node.params = tmp.params;
-        node.rest = tmp.rest;
-        node.this = tmp._this;
-        this.expect(11);
-        this.expect(19);
-        node.returnType = this.flowParseType();
-        return this.finishNode(node, "FunctionTypeAnnotation");
+        {
+          const node = this.startNode();
+          node.typeParameters = this.flowParseTypeParameterDeclaration();
+          this.expect(10);
+          tmp = this.flowParseFunctionTypeParams();
+          node.params = tmp.params;
+          node.rest = tmp.rest;
+          node.this = tmp._this;
+          this.expect(11);
+          this.expect(19);
+          node.returnType = this.flowParseType();
+          return this.finishNode(node, "FunctionTypeAnnotation");
+        }
       case 10:
-        this.next();
-        if (!this.match(11) && !this.match(21)) {
-          if (tokenIsIdentifier(this.state.type) || this.match(78)) {
-            const token = this.lookahead().type;
-            isGroupedType = token !== 17 && token !== 14;
-          } else {
-            isGroupedType = true;
+        {
+          const node = this.startNode();
+          this.next();
+          if (!this.match(11) && !this.match(21)) {
+            if (tokenIsIdentifier(this.state.type) || this.match(78)) {
+              const token = this.lookahead().type;
+              isGroupedType = token !== 17 && token !== 14;
+            } else {
+              isGroupedType = true;
+            }
           }
-        }
-        if (isGroupedType) {
-          this.state.noAnonFunctionType = false;
-          type = this.flowParseType();
-          this.state.noAnonFunctionType = oldNoAnonFunctionType;
-          if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
-            this.expect(11);
-            return type;
+          if (isGroupedType) {
+            this.state.noAnonFunctionType = false;
+            type = this.flowParseType();
+            this.state.noAnonFunctionType = oldNoAnonFunctionType;
+            if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
+              this.expect(11);
+              return type;
+            } else {
+              this.eat(12);
+            }
+          }
+          if (type) {
+            tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
           } else {
-            this.eat(12);
+            tmp = this.flowParseFunctionTypeParams();
           }
+          node.params = tmp.params;
+          node.rest = tmp.rest;
+          node.this = tmp._this;
+          this.expect(11);
+          this.expect(19);
+          node.returnType = this.flowParseType();
+          node.typeParameters = null;
+          return this.finishNode(node, "FunctionTypeAnnotation");
         }
-        if (type) {
-          tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
-        } else {
-          tmp = this.flowParseFunctionTypeParams();
-        }
-        node.params = tmp.params;
-        node.rest = tmp.rest;
-        node.this = tmp._this;
-        this.expect(11);
-        this.expect(19);
-        node.returnType = this.flowParseType();
-        node.typeParameters = null;
-        return this.finishNode(node, "FunctionTypeAnnotation");
       case 133:
         return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
       case 85:
@@ -7538,7 +7505,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     const arrows = [];
     while (stack.length !== 0) {
       const node = stack.pop();
-      if (node.type === "ArrowFunctionExpression") {
+      if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
         if (node.typeParameters || !node.returnType) {
           this.finishArrowValidation(node);
         } else {
@@ -7575,18 +7542,18 @@ var flow = superClass => class FlowParserMixin extends superClass {
     return result;
   }
   parseParenItem(node, startLoc) {
-    node = super.parseParenItem(node, startLoc);
+    const newNode = super.parseParenItem(node, startLoc);
     if (this.eat(17)) {
-      node.optional = true;
+      newNode.optional = true;
       this.resetEndLocation(node);
     }
     if (this.match(14)) {
       const typeCastNode = this.startNodeAt(startLoc);
-      typeCastNode.expression = node;
+      typeCastNode.expression = newNode;
       typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
       return this.finishNode(typeCastNode, "TypeCastExpression");
     }
-    return node;
+    return newNode;
   }
   assertModuleNodeAllowed(node) {
     if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
@@ -8959,7 +8926,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
     } else {
       let count = 0;
       let semi = false;
-      while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
+      while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) {
         ++this.state.pos;
       }
       if (semi) {
@@ -9121,7 +9088,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
             children.push(this.jsxParseElementAt(startLoc));
             break;
           case 141:
-            children.push(this.parseExprAtom());
+            children.push(this.parseLiteral(this.state.value, "JSXText"));
             break;
           case 5:
             {
@@ -9178,9 +9145,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
     context[context.length - 1] = newContext;
   }
   parseExprAtom(refExpressionErrors) {
-    if (this.match(141)) {
-      return this.parseLiteral(this.state.value, "JSXText");
-    } else if (this.match(142)) {
+    if (this.match(142)) {
       return this.jsxParseElement();
     } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
       this.replaceToken(142);
@@ -9261,14 +9226,14 @@ class TypeScriptScopeHandler extends ScopeHandler {
     return new TypeScriptScope(flags);
   }
   enter(flags) {
-    if (flags == 256) {
+    if (flags === 256) {
       this.importsStack.push(new Set());
     }
     super.enter(flags);
   }
   exit() {
     const flags = super.exit();
-    if (flags == 256) {
+    if (flags === 256) {
       this.importsStack.pop();
     }
     return flags;
@@ -9577,14 +9542,15 @@ class LValParser extends NodeUtils {
     return this.finishNode(prop, "RestElement");
   }
   parseBindingProperty() {
-    const prop = this.startNode();
     const {
       type,
       startLoc
     } = this.state;
     if (type === 21) {
-      return this.parseBindingRestProperty(prop);
-    } else if (type === 138) {
+      return this.parseBindingRestProperty(this.startNode());
+    }
+    const prop = this.startNode();
+    if (type === 138) {
       this.expectPlugin("destructuringPrivate", startLoc);
       this.classScope.usePrivateName(this.state.value, startLoc);
       prop.key = this.parsePrivateName();
@@ -11434,13 +11400,14 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   parseExport(node, decorators) {
     if (this.match(83)) {
       this.next();
+      const nodeImportEquals = node;
       let maybeDefaultIdentifier = null;
       if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
-        maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
+        maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
       } else {
-        node.importKind = "value";
+        nodeImportEquals.importKind = "value";
       }
-      return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
+      return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
     } else if (this.eat(29)) {
       const assign = node;
       assign.expression = super.parseExpression();
@@ -11612,9 +11579,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return result.node;
   }
   parseParenItem(node, startLoc) {
-    node = super.parseParenItem(node, startLoc);
+    const newNode = super.parseParenItem(node, startLoc);
     if (this.eat(17)) {
-      node.optional = true;
+      newNode.optional = true;
       this.resetEndLocation(node);
     }
     if (this.match(14)) {
@@ -11723,7 +11690,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   declareClassPrivateMethodInScope(node, kind) {
     if (node.type === "TSDeclareMethod") return;
-    if (node.type === "MethodDefinition" && !node.value.body) return;
+    if (node.type === "MethodDefinition" && !hasOwnProperty.call(node.value, "body")) {
+      return;
+    }
     super.declareClassPrivateMethodInScope(node, kind);
   }
   parseClassSuper(node) {
@@ -11922,6 +11891,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       TSTypeCastExpression: true,
       TSParameterProperty: "parameter",
       TSNonNullExpression: "expression",
+      TSInstantiationExpression: "expression",
       TSAsExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true],
       TSSatisfiesExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true],
       TSTypeAssertion: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true]
@@ -12275,9 +12245,12 @@ var placeholders = superClass => class PlaceholdersParserMixin extends superClas
     }
   }
   finishPlaceholder(node, expectedNode) {
-    const isFinished = !!(node.expectedNode && node.type === "Placeholder");
-    node.expectedNode = expectedNode;
-    return isFinished ? node : this.finishNode(node, "Placeholder");
+    let placeholder = node;
+    if (!placeholder.expectedNode || !placeholder.type) {
+      placeholder = this.finishNode(placeholder, "Placeholder");
+    }
+    placeholder.expectedNode = expectedNode;
+    return placeholder;
   }
   getTokenFromCode(code) {
     if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
@@ -12337,8 +12310,9 @@ var placeholders = superClass => class PlaceholdersParserMixin extends superClas
       return this.finishNode(stmt, "LabeledStatement");
     }
     this.semicolon();
-    node.name = expr.name;
-    return this.finishPlaceholder(node, "Statement");
+    const stmtPlaceholder = node;
+    stmtPlaceholder.name = expr.name;
+    return this.finishPlaceholder(stmtPlaceholder, "Statement");
   }
   parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
     return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
@@ -12371,17 +12345,18 @@ var placeholders = superClass => class PlaceholdersParserMixin extends superClas
   parseExport(node, decorators) {
     const placeholder = this.parsePlaceholder("Identifier");
     if (!placeholder) return super.parseExport(node, decorators);
+    const node2 = node;
     if (!this.isContextual(98) && !this.match(12)) {
-      node.specifiers = [];
-      node.source = null;
-      node.declaration = this.finishPlaceholder(placeholder, "Declaration");
-      return this.finishNode(node, "ExportNamedDeclaration");
+      node2.specifiers = [];
+      node2.source = null;
+      node2.declaration = this.finishPlaceholder(placeholder, "Declaration");
+      return this.finishNode(node2, "ExportNamedDeclaration");
     }
     this.expectPlugin("exportDefaultFrom");
     const specifier = this.startNode();
     specifier.exported = placeholder;
-    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
-    return super.parseExport(node, decorators);
+    node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
+    return super.parseExport(node2, decorators);
   }
   isExportDefaultSpecifier() {
     if (this.match(65)) {
@@ -12498,7 +12473,6 @@ function getPluginOption(plugins, name, option) {
 }
 const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
 const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
-const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
 function validatePlugins(plugins) {
   if (hasPlugin(plugins, "decorators")) {
     if (hasPlugin(plugins, "decorators-legacy")) {
@@ -12525,9 +12499,10 @@ function validatePlugins(plugins) {
       const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
       throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
     }
-    const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
+    const recordAndTupleConfigItem = ["recordAndTuple", {
       syntaxType: "hash"
-    }]);
+    }];
+    const tupleSyntaxIsHash = hasPlugin(plugins, recordAndTupleConfigItem);
     if (proposal === "hack") {
       if (hasPlugin(plugins, "placeholders")) {
         throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
@@ -12541,10 +12516,10 @@ function validatePlugins(plugins) {
         throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
       }
       if (topicToken === "#" && tupleSyntaxIsHash) {
-        throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+        throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "hack", topicToken: "#" }]\` and \`${JSON.stringify(recordAndTupleConfigItem)}\`.`);
       }
     } else if (proposal === "smart" && tupleSyntaxIsHash) {
-      throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+      throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "smart" }]\` and \`${JSON.stringify(recordAndTupleConfigItem)}\`.`);
     }
   }
   if (hasPlugin(plugins, "moduleAttributes")) {
@@ -12561,8 +12536,16 @@ function validatePlugins(plugins) {
   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(", "));
+  if (hasPlugin(plugins, "recordAndTuple")) {
+    const syntaxType = getPluginOption(plugins, "recordAndTuple", "syntaxType");
+    if (syntaxType != null) {
+      {
+        const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
+        if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) {
+          throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
+        }
+      }
+    }
   }
   if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
     const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
@@ -13681,14 +13664,16 @@ class ExpressionParser extends LValParser {
   }
   parseTemplate(isTagged) {
     const node = this.startNode();
-    node.expressions = [];
     let curElt = this.parseTemplateElement(isTagged);
-    node.quasis = [curElt];
+    const quasis = [curElt];
+    const substitutions = [];
     while (!curElt.tail) {
-      node.expressions.push(this.parseTemplateSubstitution());
+      substitutions.push(this.parseTemplateSubstitution());
       this.readTemplateContinuation();
-      node.quasis.push(curElt = this.parseTemplateElement(isTagged));
+      quasis.push(curElt = this.parseTemplateElement(isTagged));
     }
+    node.expressions = substitutions;
+    node.quasis = quasis;
     return this.finishNode(node, "TemplateLiteral");
   }
   parseTemplateSubstitution() {
@@ -13725,8 +13710,10 @@ class ExpressionParser extends LValParser {
       if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
         this.raise(Errors.InvalidRecordProperty, prop);
       }
-      if (prop.shorthand) {
-        this.addExtra(prop, "shorthand", true);
+      {
+        if (prop.shorthand) {
+          this.addExtra(prop, "shorthand", true);
+        }
       }
       node.properties.push(prop);
     }
@@ -13776,8 +13763,11 @@ class ExpressionParser extends LValParser {
     let isGenerator = this.eat(55);
     this.parsePropertyNamePrefixOperator(prop);
     const containsEsc = this.state.containsEsc;
-    const key = this.parsePropertyName(prop, refExpressionErrors);
+    this.parsePropertyName(prop, refExpressionErrors);
     if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
+      const {
+        key
+      } = prop;
       const keyName = key.name;
       if (keyName === "async" && !this.hasPrecedingLineBreak()) {
         isAsync = true;
@@ -13912,7 +13902,6 @@ class ExpressionParser extends LValParser {
         prop.computed = false;
       }
     }
-    return prop.key;
   }
   initFunction(node, isAsync) {
     node.id = null;
@@ -15322,8 +15311,11 @@ class StatementParser extends ExpressionParser {
   isClassMethod() {
     return this.match(10);
   }
+  nameIsConstructor(key) {
+    return key.type === "Identifier" && key.name === "constructor" || key.type === "StringLiteral" && key.value === "constructor";
+  }
   isNonstaticConstructor(method) {
-    return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
+    return !method.computed && !method.static && this.nameIsConstructor(method.key);
   }
   parseClassBody(hadSuperClass, oldStrict) {
     this.classScope.enter();
@@ -15425,9 +15417,10 @@ class StatementParser extends ExpressionParser {
       this.pushClassMethod(classBody, publicMethod, true, false, false, false);
       return;
     }
-    const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
-    const isPrivate = this.match(138);
+    const isContextual = !this.state.containsEsc && tokenIsIdentifier(this.state.type);
     const key = this.parseClassElementName(member);
+    const maybeContextualKw = isContextual ? key.name : null;
+    const isPrivate = this.isPrivateName(key);
     const maybeQuestionTokenStartLoc = this.state.startLoc;
     this.parsePostMemberNameModifiers(publicMember);
     if (this.isClassMethod()) {
@@ -15456,7 +15449,7 @@ class StatementParser extends ExpressionParser {
       } else {
         this.pushClassProperty(classBody, publicProp);
       }
-    } else if (isContextual && key.name === "async" && !this.isLineTerminator()) {
+    } else if (maybeContextualKw === "async" && !this.isLineTerminator()) {
       this.resetPreviousNodeTrailingComments(key);
       const isGenerator = this.eat(55);
       if (publicMember.optional) {
@@ -15474,9 +15467,9 @@ class StatementParser extends ExpressionParser {
         }
         this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
       }
-    } else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) {
+    } else if ((maybeContextualKw === "get" || maybeContextualKw === "set") && !(this.match(55) && this.isLineTerminator())) {
       this.resetPreviousNodeTrailingComments(key);
-      method.kind = key.name;
+      method.kind = maybeContextualKw;
       const isPrivate = this.match(138);
       this.parseClassElementName(publicMethod);
       if (isPrivate) {
@@ -15488,7 +15481,7 @@ class StatementParser extends ExpressionParser {
         this.pushClassMethod(classBody, publicMethod, false, false, false, false);
       }
       this.checkGetterSetterParams(publicMethod);
-    } else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) {
+    } else if (maybeContextualKw === "accessor" && !this.isLineTerminator()) {
       this.expectPlugin("decoratorAutoAccessors");
       this.resetPreviousNodeTrailingComments(key);
       const isPrivate = this.match(138);
@@ -15520,7 +15513,8 @@ class StatementParser extends ExpressionParser {
       member.key = key;
       return key;
     }
-    return this.parsePropertyName(member);
+    this.parsePropertyName(member);
+    return member.key;
   }
   parseClassStaticBlock(classBody, member) {
     var _member$decorators;
@@ -15539,7 +15533,7 @@ class StatementParser extends ExpressionParser {
     }
   }
   pushClassProperty(classBody, prop) {
-    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
+    if (!prop.computed && this.nameIsConstructor(prop.key)) {
       this.raise(Errors.ConstructorClassField, prop.key);
     }
     classBody.body.push(this.parseClassProperty(prop));
@@ -15550,11 +15544,8 @@ class StatementParser extends ExpressionParser {
     this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
   }
   pushClassAccessorProperty(classBody, prop, isPrivate) {
-    if (!isPrivate && !prop.computed) {
-      const key = prop.key;
-      if (key.name === "constructor" || key.value === "constructor") {
-        this.raise(Errors.ConstructorClassField, key);
-      }
+    if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) {
+      this.raise(Errors.ConstructorClassField, prop.key);
     }
     const node = this.parseClassAccessorProperty(prop);
     classBody.body.push(node);
@@ -15690,7 +15681,8 @@ class StatementParser extends ExpressionParser {
   }
   maybeParseExportNamespaceSpecifier(node) {
     if (this.isContextual(93)) {
-      if (!node.specifiers) node.specifiers = [];
+      var _ref, _ref$specifiers;
+      (_ref$specifiers = (_ref = node).specifiers) != null ? _ref$specifiers : _ref.specifiers = [];
       const specifier = this.startNodeAt(this.state.lastTokStartLoc);
       this.next();
       specifier.exported = this.parseModuleExportName();
@@ -15701,13 +15693,14 @@ class StatementParser extends ExpressionParser {
   }
   maybeParseExportNamedSpecifiers(node) {
     if (this.match(5)) {
-      if (!node.specifiers) node.specifiers = [];
-      const isTypeExport = node.exportKind === "type";
-      node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
-      node.source = null;
-      node.declaration = null;
+      const node2 = node;
+      if (!node2.specifiers) node2.specifiers = [];
+      const isTypeExport = node2.exportKind === "type";
+      node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
+      node2.source = null;
+      node2.declaration = null;
       if (this.hasPlugin("importAssertions")) {
-        node.assertions = [];
+        node2.assertions = [];
       }
       return true;
     }
@@ -15818,6 +15811,14 @@ class StatementParser extends ExpressionParser {
         return true;
       }
     }
+    if (this.isContextual(107)) {
+      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
+      return true;
+    }
+    if (this.isContextual(96) && this.startsAwaitUsing()) {
+      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
+      return true;
+    }
     return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
   }
   checkExport(node, checkNames, isDefault, isFrom) {
@@ -15855,12 +15856,15 @@ class StatementParser extends ExpressionParser {
           }
         }
       } else if (node.declaration) {
-        if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
-          const id = node.declaration.id;
+        const decl = node.declaration;
+        if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+          const {
+            id
+          } = decl;
           if (!id) throw new Error("Assertion failure");
           this.checkDuplicateExports(node, id.name);
-        } else if (node.declaration.type === "VariableDeclaration") {
-          for (const declaration of node.declaration.declarations) {
+        } else if (decl.type === "VariableDeclaration") {
+          for (const declaration of decl.declarations) {
             this.checkDeclaration(declaration.id);
           }
         }
@@ -16570,7 +16574,8 @@ function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [
         if (includeAll || isRefed && !isLocal) {
           onIdentifier(node, parent, parentStack, isRefed, isLocal);
         }
-      } else if (node.type === "ObjectProperty" && (parent == null ? void 0 : parent.type) === "ObjectPattern") {
+      } else if (node.type === "ObjectProperty" && // eslint-disable-next-line no-restricted-syntax
+      (parent == null ? void 0 : parent.type) === "ObjectPattern") {
         node.inPattern = true;
       } else if (isFunctionType(node)) {
         if (node.scopeIds) {
@@ -16661,16 +16666,14 @@ function walkFunctionParams(node, onIdent) {
 function walkBlockDeclarations(block, onIdent) {
   for (const stmt of block.body) {
     if (stmt.type === "VariableDeclaration") {
-      if (stmt.declare)
-        continue;
+      if (stmt.declare) continue;
       for (const decl of stmt.declarations) {
         for (const id of extractIdentifiers$1(decl.id)) {
           onIdent(id);
         }
       }
     } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
-      if (stmt.declare || !stmt.id)
-        continue;
+      if (stmt.declare || !stmt.id) continue;
       onIdent(stmt.id);
     } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
       const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
@@ -16707,8 +16710,7 @@ function extractIdentifiers$1(param, nodes = []) {
       break;
     case "ArrayPattern":
       param.elements.forEach((element) => {
-        if (element)
-          extractIdentifiers$1(element, nodes);
+        if (element) extractIdentifiers$1(element, nodes);
       });
       break;
     case "RestElement":
@@ -16861,7 +16863,7 @@ function isCoreComponent(tag) {
       return BASE_TRANSITION;
   }
 }
-const nonIdentifierRE = /^\d|[^\$\w]/;
+const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
 const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
 const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
 const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
@@ -16982,8 +16984,7 @@ function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
   for (let i = 0; i < node.props.length; i++) {
     const p = node.props[i];
     if (p.type === 6) {
-      if (dynamicOnly)
-        continue;
+      if (dynamicOnly) continue;
       if (p.name === name && (p.value || allowEmpty)) {
         return p;
       }
@@ -17135,6 +17136,7 @@ function hasScopeRef(node, ids) {
       return hasScopeRef(node.content, ids);
     case 2:
     case 3:
+    case 20:
       return false;
     default:
       return false;
@@ -17147,7 +17149,7 @@ function getMemoedVNodeCall(node) {
     return node;
   }
 }
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
 
 const defaultParserOptions = {
   parseMode: "base",
@@ -17300,8 +17302,7 @@ const tokenizer$2 = new Tokenizer$1(stack, {
     }
   },
   ondirarg(start, end) {
-    if (start === end)
-      return;
+    if (start === end) return;
     const arg = getSlice(start, end);
     if (inVPre) {
       currentProp.name += arg;
@@ -17333,14 +17334,12 @@ const tokenizer$2 = new Tokenizer$1(stack, {
   },
   onattribdata(start, end) {
     currentAttrValue += getSlice(start, end);
-    if (currentAttrStartIndex < 0)
-      currentAttrStartIndex = start;
+    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
     currentAttrEndIndex = end;
   },
   onattribentity(char, start, end) {
     currentAttrValue += char;
-    if (currentAttrStartIndex < 0)
-      currentAttrStartIndex = start;
+    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
     currentAttrEndIndex = end;
   },
   onattribnameend(end) {
@@ -17480,8 +17479,7 @@ function parseForExpression(input) {
   const loc = input.loc;
   const exp = input.content;
   const inMatch = exp.match(forAliasRE);
-  if (!inMatch)
-    return;
+  if (!inMatch) return;
   const [, LHS, RHS] = inMatch;
   const createAliasExpression = (content, offset, asParam = false) => {
     const start = loc.start.offset + offset;
@@ -17610,14 +17608,12 @@ function onCloseTag(el, end, isImplied = false) {
 }
 function lookAhead(index, c) {
   let i = index;
-  while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1)
-    i++;
+  while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
   return i;
 }
 function backTrack(index, c) {
   let i = index;
-  while (currentInput.charCodeAt(i) !== c && i >= 0)
-    i--;
+  while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
   return i;
 }
 const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
@@ -17836,9 +17832,10 @@ function baseParse(input, options) {
   return root;
 }
 
-function hoistStatic(root, context) {
+function cacheStatic(root, context) {
   walk$1(
     root,
+    void 0,
     context,
     // Root node is unfortunately non-hoistable due to potential parent
     // fallthrough attributes.
@@ -17849,26 +17846,24 @@ function isSingleElementRoot(root, child) {
   const { children } = root;
   return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
 }
-function walk$1(node, context, doNotHoistNode = false) {
+function walk$1(node, parent, context, doNotHoistNode = false, inFor = false) {
   const { children } = node;
-  const originalCount = children.length;
-  let hoistedCount = 0;
+  const toCache = [];
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
     if (child.type === 1 && child.tagType === 0) {
       const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
       if (constantType > 0) {
         if (constantType >= 2) {
-          child.codegenNode.patchFlag = -1 + (` /* HOISTED */` );
-          child.codegenNode = context.hoist(child.codegenNode);
-          hoistedCount++;
+          child.codegenNode.patchFlag = -1;
+          toCache.push(child);
           continue;
         }
       } else {
         const codegenNode = child.codegenNode;
         if (codegenNode.type === 13) {
-          const flag = getPatchFlag(codegenNode);
-          if ((!flag || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
+          const flag = codegenNode.patchFlag;
+          if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
             const props = getNodeProps(child);
             if (props) {
               codegenNode.props = context.hoist(props);
@@ -17879,39 +17874,84 @@ function walk$1(node, context, doNotHoistNode = false) {
           }
         }
       }
+    } else if (child.type === 12) {
+      const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
+      if (constantType >= 2) {
+        toCache.push(child);
+        continue;
+      }
     }
     if (child.type === 1) {
       const isComponent = child.tagType === 1;
       if (isComponent) {
         context.scopes.vSlot++;
       }
-      walk$1(child, context);
+      walk$1(child, node, context, false, inFor);
       if (isComponent) {
         context.scopes.vSlot--;
       }
     } else if (child.type === 11) {
-      walk$1(child, context, child.children.length === 1);
+      walk$1(child, node, context, child.children.length === 1, true);
     } else if (child.type === 9) {
       for (let i2 = 0; i2 < child.branches.length; i2++) {
         walk$1(
           child.branches[i2],
+          node,
           context,
-          child.branches[i2].children.length === 1
+          child.branches[i2].children.length === 1,
+          inFor
         );
       }
     }
   }
-  if (hoistedCount && context.transformHoist) {
-    context.transformHoist(children, context, node);
+  let cachedAsArray = false;
+  if (toCache.length === children.length && node.type === 1) {
+    if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray$3(node.codegenNode.children)) {
+      node.codegenNode.children = getCacheExpression(
+        createArrayExpression(node.codegenNode.children)
+      );
+      cachedAsArray = true;
+    } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray$3(node.codegenNode.children) && node.codegenNode.children.type === 15) {
+      const slot = getSlotNode(node.codegenNode, "default");
+      if (slot) {
+        slot.returns = getCacheExpression(
+          createArrayExpression(slot.returns)
+        );
+        cachedAsArray = true;
+      }
+    } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray$3(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
+      const slotName = findDir(node, "slot", true);
+      const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
+      if (slot) {
+        slot.returns = getCacheExpression(
+          createArrayExpression(slot.returns)
+        );
+        cachedAsArray = true;
+      }
+    }
   }
-  if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray$3(node.codegenNode.children)) {
-    const hoisted = context.hoist(
-      createArrayExpression(node.codegenNode.children)
-    );
-    if (context.hmr) {
-      hoisted.content = `[...${hoisted.content}]`;
+  if (!cachedAsArray) {
+    for (const child of toCache) {
+      child.codegenNode = context.cache(child.codegenNode);
+    }
+  }
+  function getCacheExpression(value) {
+    const exp = context.cache(value);
+    if (inFor && context.hmr) {
+      exp.needArraySpread = true;
+    }
+    return exp;
+  }
+  function getSlotNode(node2, name) {
+    if (node2.children && !isArray$3(node2.children) && node2.children.type === 15) {
+      const slot = node2.children.properties.find(
+        (p) => p.key === name || p.key.content === name
+      );
+      return slot && slot.value;
     }
-    node.codegenNode.children = hoisted;
+  }
+  if (toCache.length && context.transformHoist) {
+    context.transformHoist(children, context, node);
   }
 }
 function getConstantType(node, context) {
@@ -17929,11 +17969,10 @@ function getConstantType(node, context) {
       if (codegenNode.type !== 13) {
         return 0;
       }
-      if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject") {
+      if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") {
         return 0;
       }
-      const flag = getPatchFlag(codegenNode);
-      if (!flag) {
+      if (codegenNode.patchFlag === void 0) {
         let returnType2 = 3;
         const generatedPropsType = getGeneratedPropsConstantType(node, context);
         if (generatedPropsType === 0) {
@@ -18016,6 +18055,8 @@ function getConstantType(node, context) {
         }
       }
       return returnType;
+    case 20:
+      return 2;
     default:
       return 0;
   }
@@ -18075,15 +18116,11 @@ function getNodeProps(node) {
     return codegenNode.props;
   }
 }
-function getPatchFlag(node) {
-  const flag = node.patchFlag;
-  return flag ? parseInt(flag, 10) : void 0;
-}
 
 function createTransformContext(root, {
   filename = "",
   prefixIdentifiers = false,
-  hoistStatic: hoistStatic2 = false,
+  hoistStatic = false,
   hmr = false,
   cacheHandlers = false,
   nodeTransforms = [],
@@ -18110,7 +18147,7 @@ function createTransformContext(root, {
     filename,
     selfName: nameMatch && capitalize$1(camelize(nameMatch[1])),
     prefixIdentifiers,
-    hoistStatic: hoistStatic2,
+    hoistStatic,
     hmr,
     cacheHandlers,
     nodeTransforms,
@@ -18137,9 +18174,9 @@ function createTransformContext(root, {
     directives: /* @__PURE__ */ new Set(),
     hoists: [],
     imports: [],
+    cached: [],
     constantCache: /* @__PURE__ */ new WeakMap(),
     temps: 0,
-    cached: 0,
     identifiers: /* @__PURE__ */ Object.create(null),
     scopes: {
       vFor: 0,
@@ -18227,8 +18264,7 @@ function createTransformContext(root, {
       }
     },
     hoist(exp) {
-      if (isString$2(exp))
-        exp = createSimpleExpression(exp);
+      if (isString$2(exp)) exp = createSimpleExpression(exp);
       context.hoists.push(exp);
       const identifier = createSimpleExpression(
         `_hoisted_${context.hoists.length}`,
@@ -18240,7 +18276,13 @@ function createTransformContext(root, {
       return identifier;
     },
     cache(exp, isVNode = false) {
-      return createCacheExpression(context.cached++, exp, isVNode);
+      const cacheExp = createCacheExpression(
+        context.cached.length,
+        exp,
+        isVNode
+      );
+      context.cached.push(cacheExp);
+      return cacheExp;
     }
   };
   function addId(id) {
@@ -18259,7 +18301,7 @@ function transform(root, options) {
   const context = createTransformContext(root, options);
   traverseNode(root, context);
   if (options.hoistStatic) {
-    hoistStatic(root, context);
+    cacheStatic(root, context);
   }
   if (!options.ssr) {
     createRootCodegen(root, context);
@@ -18299,7 +18341,7 @@ function createRootCodegen(root, context) {
       helper(FRAGMENT),
       void 0,
       root.children,
-      patchFlag + (` /* ${patchFlagText} */` ),
+      patchFlag,
       void 0,
       void 0,
       true,
@@ -18315,8 +18357,7 @@ function traverseChildren(parent, context) {
   };
   for (; i < parent.children.length; i++) {
     const child = parent.children[i];
-    if (isString$2(child))
-      continue;
+    if (isString$2(child)) continue;
     context.grandParent = context.parent;
     context.parent = parent;
     context.childIndex = i;
@@ -18387,8 +18428,7 @@ function createStructuralDirectiveTransform(name, fn) {
           props.splice(i, 1);
           i--;
           const onExit = fn(node, prop, context);
-          if (onExit)
-            exitFns.push(onExit);
+          if (onExit) exitFns.push(onExit);
         }
       }
       return exitFns;
@@ -21827,8 +21867,7 @@ function createCodegenContext(ast, {
   }
   function addMapping(loc, name = null) {
     const { _names, _mappings } = context.map;
-    if (name !== null && !_names.has(name))
-      _names.add(name);
+    if (name !== null && !_names.has(name)) _names.add(name);
     _mappings.add({
       originalLine: loc.line,
       originalColumn: loc.column - 1,
@@ -21848,8 +21887,7 @@ function createCodegenContext(ast, {
 }
 function generate(ast, options = {}) {
   const context = createCodegenContext(ast, options);
-  if (options.onContextCreated)
-    options.onContextCreated(context);
+  if (options.onContextCreated) options.onContextCreated(context);
   const {
     mode,
     push,
@@ -21993,10 +22031,6 @@ function genModulePreamble(ast, context, genScopeId, inline) {
     runtimeModuleName,
     ssrRuntimeModuleName
   } = context;
-  if (genScopeId && ast.hoists.length) {
-    ast.helpers.add(PUSH_SCOPE_ID);
-    ast.helpers.add(POP_SCOPE_ID);
-  }
   if (ast.helpers.size) {
     const helpers = Array.from(ast.helpers);
     if (optimizeImports) {
@@ -22060,28 +22094,13 @@ function genHoists(hoists, context) {
     return;
   }
   context.pure = true;
-  const { push, newline, helper, scopeId, mode } = context;
-  const genScopeId = scopeId != null && mode !== "function";
+  const { push, newline } = context;
   newline();
-  if (genScopeId) {
-    push(
-      `const _withScopeId = n => (${helper(
-        PUSH_SCOPE_ID
-      )}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
-    );
-    newline();
-  }
   for (let i = 0; i < hoists.length; i++) {
     const exp = hoists[i];
     if (exp) {
-      const needScopeIdWrapper = genScopeId && exp.type === 13;
-      push(
-        `const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`
-      );
+      push(`const _hoisted_${i + 1} = `);
       genNode(exp, context);
-      if (needScopeIdWrapper) {
-        push(`)`);
-      }
       newline();
     }
   }
@@ -22229,8 +22248,7 @@ function genExpression(node, context) {
 }
 function genInterpolation(node, context) {
   const { push, helper, pure } = context;
-  if (pure)
-    push(PURE_ANNOTATION);
+  if (pure) push(PURE_ANNOTATION);
   push(`${helper(TO_DISPLAY_STRING)}(`);
   genNode(node.content, context);
   push(`)`);
@@ -22282,6 +22300,17 @@ function genVNodeCall(node, context) {
     disableTracking,
     isComponent
   } = node;
+  let patchFlagString;
+  if (patchFlag) {
+    {
+      if (patchFlag < 0) {
+        patchFlagString = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
+      } else {
+        const flagNames = Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `);
+        patchFlagString = patchFlag + ` /* ${flagNames} */`;
+      }
+    }
+  }
   if (directives) {
     push(helper(WITH_DIRECTIVES) + `(`);
   }
@@ -22294,7 +22323,7 @@ function genVNodeCall(node, context) {
   const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
   push(helper(callHelper) + `(`, -2 /* None */, node);
   genNodeList(
-    genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
+    genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),
     context
   );
   push(`)`);
@@ -22310,8 +22339,7 @@ function genVNodeCall(node, context) {
 function genNullableArgs(args) {
   let i = args.length;
   while (i--) {
-    if (args[i] != null)
-      break;
+    if (args[i] != null) break;
   }
   return args.slice(0, i + 1).map((arg) => arg || `null`);
 }
@@ -22425,16 +22453,21 @@ function genConditionalExpression(node, context) {
 }
 function genCacheExpression(node, context) {
   const { push, helper, indent, deindent, newline } = context;
+  const { needPauseTracking, needArraySpread } = node;
+  if (needArraySpread) {
+    push(`[...(`);
+  }
   push(`_cache[${node.index}] || (`);
-  if (node.isVNode) {
+  if (needPauseTracking) {
     indent();
     push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
     newline();
+    push(`(`);
   }
   push(`_cache[${node.index}] = `);
   genNode(node.value, context);
-  if (node.isVNode) {
-    push(`,`);
+  if (needPauseTracking) {
+    push(`).cacheIndex = ${node.index},`);
     newline();
     push(`${helper(SET_BLOCK_TRACKING)}(1),`);
     newline();
@@ -22442,6 +22475,9 @@ function genCacheExpression(node, context) {
     deindent();
   }
   push(`)`);
+  if (needArraySpread) {
+    push(`)]`);
+  }
 }
 function genTemplateLiteral(node, context) {
   const { push, indent, deindent } = context;
@@ -22454,11 +22490,9 @@ function genTemplateLiteral(node, context) {
       push(e.replace(/(`|\$|\\)/g, "\\$1"), -3 /* Unknown */);
     } else {
       push("${");
-      if (multilines)
-        indent();
+      if (multilines) indent();
       genNode(e, context);
-      if (multilines)
-        deindent();
+      if (multilines) deindent();
       push("}");
     }
   }
@@ -22659,7 +22693,7 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
         node2.name = rewriteIdentifier(node2.name, parent, node2);
         ids.push(node2);
       } else {
-        if (!(needPrefix && isLocal) && parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression") {
+        if (!(needPrefix && isLocal) && (!parent || parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression")) {
           node2.isConstant = true;
         }
         ids.push(node2);
@@ -22829,8 +22863,7 @@ function processIf(node, dir, context, processCodegen) {
         sibling.branches.push(branch);
         const onExit = processCodegen && processCodegen(sibling, branch, false);
         traverseNode(branch, context);
-        if (onExit)
-          onExit();
+        if (onExit) onExit();
         context.currentNode = null;
       } else {
         context.onError(
@@ -22899,7 +22932,7 @@ function createChildrenCodegenNode(branch, keyIndex, context) {
         helper(FRAGMENT),
         createObjectExpression([keyProperty]),
         children,
-        patchFlag + (` /* ${patchFlagText} */` ),
+        patchFlag,
         void 0,
         void 0,
         true,
@@ -22952,6 +22985,90 @@ function getParentCondition(node) {
   }
 }
 
+const transformBind = (dir, _node, context) => {
+  const { modifiers, loc } = dir;
+  const arg = dir.arg;
+  let { exp } = dir;
+  if (exp && exp.type === 4 && !exp.content.trim()) {
+    {
+      context.onError(
+        createCompilerError(34, loc)
+      );
+      return {
+        props: [
+          createObjectProperty(arg, createSimpleExpression("", true, loc))
+        ]
+      };
+    }
+  }
+  if (!exp) {
+    if (arg.type !== 4 || !arg.isStatic) {
+      context.onError(
+        createCompilerError(
+          52,
+          arg.loc
+        )
+      );
+      return {
+        props: [
+          createObjectProperty(arg, createSimpleExpression("", true, loc))
+        ]
+      };
+    }
+    transformBindShorthand(dir, context);
+    exp = dir.exp;
+  }
+  if (arg.type !== 4) {
+    arg.children.unshift(`(`);
+    arg.children.push(`) || ""`);
+  } else if (!arg.isStatic) {
+    arg.content = `${arg.content} || ""`;
+  }
+  if (modifiers.includes("camel")) {
+    if (arg.type === 4) {
+      if (arg.isStatic) {
+        arg.content = camelize(arg.content);
+      } else {
+        arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
+      }
+    } else {
+      arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
+      arg.children.push(`)`);
+    }
+  }
+  if (!context.inSSR) {
+    if (modifiers.includes("prop")) {
+      injectPrefix(arg, ".");
+    }
+    if (modifiers.includes("attr")) {
+      injectPrefix(arg, "^");
+    }
+  }
+  return {
+    props: [createObjectProperty(arg, exp)]
+  };
+};
+const transformBindShorthand = (dir, context) => {
+  const arg = dir.arg;
+  const propName = camelize(arg.content);
+  dir.exp = createSimpleExpression(propName, false, arg.loc);
+  {
+    dir.exp = processExpression(dir.exp, context);
+  }
+};
+const injectPrefix = (arg, prefix) => {
+  if (arg.type === 4) {
+    if (arg.isStatic) {
+      arg.content = prefix + arg.content;
+    } else {
+      arg.content = `\`${prefix}\${${arg.content}}\``;
+    }
+  } else {
+    arg.children.unshift(`'${prefix}' + (`);
+    arg.children.push(`)`);
+  }
+};
+
 const transformFor = createStructuralDirectiveTransform(
   "for",
   (node, dir, context) => {
@@ -22962,9 +23079,12 @@ const transformFor = createStructuralDirectiveTransform(
       ]);
       const isTemplate = isTemplateNode(node);
       const memo = findDir(node, "memo");
-      const keyProp = findProp(node, `key`);
-      const keyExp = keyProp && (keyProp.type === 6 ? createSimpleExpression(keyProp.value.content, true) : keyProp.exp);
-      const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
+      const keyProp = findProp(node, `key`, false, true);
+      if (keyProp && keyProp.type === 7 && !keyProp.exp) {
+        transformBindShorthand(keyProp, context);
+      }
+      const keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
+      const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
       if (isTemplate) {
         if (memo) {
           memo.exp = processExpression(
@@ -22986,7 +23106,7 @@ const transformFor = createStructuralDirectiveTransform(
         helper(FRAGMENT),
         void 0,
         renderExp,
-        fragmentFlag + (` /* ${PatchFlagNames[fragmentFlag]} */` ),
+        fragmentFlag,
         void 0,
         void 0,
         true,
@@ -23026,7 +23146,7 @@ const transformFor = createStructuralDirectiveTransform(
             helper(FRAGMENT),
             keyProperty ? createObjectExpression([keyProperty]) : void 0,
             node.children,
-            64 + (` /* ${PatchFlagNames[64]} */` ),
+            64,
             void 0,
             void 0,
             true,
@@ -23080,8 +23200,9 @@ const transformFor = createStructuralDirectiveTransform(
           renderExp.arguments.push(
             loop,
             createSimpleExpression(`_cache`),
-            createSimpleExpression(String(context.cached++))
+            createSimpleExpression(String(context.cached.length))
           );
+          context.cached.push(null);
         } else {
           renderExp.arguments.push(
             createFunctionExpression(
@@ -23137,13 +23258,11 @@ function processFor(node, dir, context, processCodegen) {
       key && removeIdentifiers(key);
       index && removeIdentifiers(index);
     }
-    if (onExit)
-      onExit();
+    if (onExit) onExit();
   };
 }
 function finalizeForParseResult(result, context) {
-  if (result.finalized)
-    return;
+  if (result.finalized) return;
   if (context.prefixIdentifiers) {
     result.source = processExpression(
       result.source,
@@ -23179,8 +23298,7 @@ function createForLoopParams({ value, key, index }, memoArgs = []) {
 function createParamsList(args) {
   let i = args.length;
   while (i--) {
-    if (args[i])
-      break;
+    if (args[i]) break;
   }
   return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
 }
@@ -23312,9 +23430,7 @@ function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
           break;
         }
       }
-      if (prev && isTemplateNode(prev) && findDir(prev, "if")) {
-        children.splice(i, 1);
-        i--;
+      if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
         let conditional = dynamicSlots[dynamicSlots.length - 1];
         while (conditional.alternate.type === 19) {
           conditional = conditional.alternate;
@@ -23448,13 +23564,11 @@ function hasForwardedSlots(children) {
         }
         break;
       case 9:
-        if (hasForwardedSlots(child.branches))
-          return true;
+        if (hasForwardedSlots(child.branches)) return true;
         break;
       case 10:
       case 11:
-        if (hasForwardedSlots(child.children))
-          return true;
+        if (hasForwardedSlots(child.children)) return true;
         break;
     }
   }
@@ -23479,7 +23593,6 @@ const transformElement = (node, context) => {
     const isDynamicComponent = isObject$2(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
     let vnodeProps;
     let vnodeChildren;
-    let vnodePatchFlag;
     let patchFlag = 0;
     let vnodeDynamicProps;
     let dynamicPropNames;
@@ -23490,7 +23603,7 @@ const transformElement = (node, context) => {
       // updates inside get proper isSVG flag at runtime. (#639, #643)
       // This is technically web-specific, but splitting the logic out of core
       // leads to too much unnecessary complexity.
-      (tag === "svg" || tag === "foreignObject")
+      (tag === "svg" || tag === "foreignObject" || tag === "math")
     );
     if (props.length > 0) {
       const propsBuildResult = buildProps(
@@ -23550,25 +23663,15 @@ const transformElement = (node, context) => {
         vnodeChildren = node.children;
       }
     }
-    if (patchFlag !== 0) {
-      {
-        if (patchFlag < 0) {
-          vnodePatchFlag = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
-        } else {
-          const flagNames = Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `);
-          vnodePatchFlag = patchFlag + ` /* ${flagNames} */`;
-        }
-      }
-      if (dynamicPropNames && dynamicPropNames.length) {
-        vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
-      }
+    if (dynamicPropNames && dynamicPropNames.length) {
+      vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
     }
     node.codegenNode = createVNodeCall(
       context,
       vnodeTag,
       vnodeProps,
       vnodeChildren,
-      vnodePatchFlag,
+      patchFlag === 0 ? void 0 : patchFlag,
       vnodeDynamicProps,
       vnodeDirectives,
       !!shouldUseBlock,
@@ -23613,8 +23716,7 @@ function resolveComponentType(node, context, ssr = false) {
   }
   const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
   if (builtIn) {
-    if (!ssr)
-      context.helper(builtIn);
+    if (!ssr) context.helper(builtIn);
     return builtIn;
   }
   {
@@ -23698,8 +23800,7 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
       );
       properties = [];
     }
-    if (arg)
-      mergeArgs.push(arg);
+    if (arg) mergeArgs.push(arg);
   };
   const pushRefVForMarker = () => {
     if (context.scopes.vFor > 0) {
@@ -24015,8 +24116,7 @@ function buildDirectiveArgs(dir, context) {
     }
   }
   const { loc } = dir;
-  if (dir.exp)
-    dirArgs.push(dir.exp);
+  if (dir.exp) dirArgs.push(dir.exp);
   if (dir.arg) {
     if (!dir.exp) {
       dirArgs.push(`void 0`);
@@ -24046,8 +24146,7 @@ function stringifyDynamicPropNames(props) {
   let propsNamesString = `[`;
   for (let i = 0, l = props.length; i < l; i++) {
     propsNamesString += JSON.stringify(props[i]);
-    if (i < l - 1)
-      propsNamesString += ", ";
+    if (i < l - 1) propsNamesString += ", ";
   }
   return propsNamesString + `]`;
 }
@@ -24144,7 +24243,7 @@ function processSlotOutlet(node, context) {
   };
 }
 
-const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
 const transformOn$1 = (dir, node, context, augmentor) => {
   const { loc, modifiers, arg } = dir;
   if (!dir.exp && !modifiers.length) {
@@ -24247,85 +24346,6 @@ const transformOn$1 = (dir, node, context, augmentor) => {
   return ret;
 };
 
-const transformBind = (dir, _node, context) => {
-  const { modifiers, loc } = dir;
-  const arg = dir.arg;
-  let { exp } = dir;
-  if (exp && exp.type === 4 && !exp.content.trim()) {
-    {
-      context.onError(
-        createCompilerError(34, loc)
-      );
-      return {
-        props: [
-          createObjectProperty(arg, createSimpleExpression("", true, loc))
-        ]
-      };
-    }
-  }
-  if (!exp) {
-    if (arg.type !== 4 || !arg.isStatic) {
-      context.onError(
-        createCompilerError(
-          52,
-          arg.loc
-        )
-      );
-      return {
-        props: [
-          createObjectProperty(arg, createSimpleExpression("", true, loc))
-        ]
-      };
-    }
-    const propName = camelize(arg.content);
-    exp = dir.exp = createSimpleExpression(propName, false, arg.loc);
-    {
-      exp = dir.exp = processExpression(exp, context);
-    }
-  }
-  if (arg.type !== 4) {
-    arg.children.unshift(`(`);
-    arg.children.push(`) || ""`);
-  } else if (!arg.isStatic) {
-    arg.content = `${arg.content} || ""`;
-  }
-  if (modifiers.includes("camel")) {
-    if (arg.type === 4) {
-      if (arg.isStatic) {
-        arg.content = camelize(arg.content);
-      } else {
-        arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
-      }
-    } else {
-      arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
-      arg.children.push(`)`);
-    }
-  }
-  if (!context.inSSR) {
-    if (modifiers.includes("prop")) {
-      injectPrefix(arg, ".");
-    }
-    if (modifiers.includes("attr")) {
-      injectPrefix(arg, "^");
-    }
-  }
-  return {
-    props: [createObjectProperty(arg, exp)]
-  };
-};
-const injectPrefix = (arg, prefix) => {
-  if (arg.type === 4) {
-    if (arg.isStatic) {
-      arg.content = prefix + arg.content;
-    } else {
-      arg.content = `\`${prefix}\${${arg.content}}\``;
-    }
-  } else {
-    arg.children.unshift(`'${prefix}' + (`);
-    arg.children.push(`)`);
-  }
-};
-
 const transformText = (node, context) => {
   if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
     return () => {
@@ -24524,8 +24544,9 @@ const transformMemo = (node, context) => {
           dir.exp,
           createFunctionExpression(void 0, codegenNode),
           `_cache`,
-          String(context.cached++)
+          String(context.cached.length)
         ]);
+        context.cached.push(null);
       }
     };
   }
@@ -24944,8 +24965,7 @@ const transformClick = (key, event) => {
 const transformOn = (dir, node, context) => {
   return transformOn$1(dir, node, context, (baseResult) => {
     const { modifiers } = dir;
-    if (!modifiers.length)
-      return baseResult;
+    if (!modifiers.length) return baseResult;
     let { key, value: handlerExp } = baseResult.props[0];
     const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
     if (nonKeyModifiers.includes("right")) {
@@ -25041,6 +25061,7 @@ const stringifyStatic = (children, context, parent) => {
   if (context.scopes.vSlot > 0) {
     return;
   }
+  const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray$3(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
   let nc = 0;
   let ec = 0;
   const currentChunk = [];
@@ -25054,14 +25075,25 @@ const stringifyStatic = (children, context, parent) => {
         // will insert / hydrate
         String(currentChunk.length)
       ]);
-      replaceHoist(currentChunk[0], staticCall, context);
-      if (currentChunk.length > 1) {
-        for (let i2 = 1; i2 < currentChunk.length; i2++) {
-          replaceHoist(currentChunk[i2], null, context);
+      if (isParentCached) {
+        parent.codegenNode.children.value = createArrayExpression([staticCall]);
+      } else {
+        currentChunk[0].codegenNode.value = staticCall;
+        if (currentChunk.length > 1) {
+          const deleteCount = currentChunk.length - 1;
+          children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+          const cacheIndex = context.cached.indexOf(
+            currentChunk[currentChunk.length - 1].codegenNode
+          );
+          if (cacheIndex > -1) {
+            for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
+              const c = context.cached[i2];
+              if (c) c.index -= deleteCount;
+            }
+            context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
+          }
+          return deleteCount;
         }
-        const deleteCount = currentChunk.length - 1;
-        children.splice(currentIndex - currentChunk.length + 1, deleteCount);
-        return deleteCount;
       }
     }
     return 0;
@@ -25069,14 +25101,13 @@ const stringifyStatic = (children, context, parent) => {
   let i = 0;
   for (; i < children.length; i++) {
     const child = children[i];
-    const hoisted = getHoistedNode(child);
-    if (hoisted) {
-      const node = child;
-      const result = analyzeNode(node);
+    const isCached = isParentCached || getCachedNode(child);
+    if (isCached) {
+      const result = analyzeNode(child);
       if (result) {
         nc += result[0];
         ec += result[1];
-        currentChunk.push(node);
+        currentChunk.push(child);
         continue;
       }
     }
@@ -25087,15 +25118,15 @@ const stringifyStatic = (children, context, parent) => {
   }
   stringifyCurrentChunk(i);
 };
-const getHoistedNode = (node) => (node.type === 1 && node.tagType === 0 || node.type == 12) && node.codegenNode && node.codegenNode.type === 4 && node.codegenNode.hoisted;
+const getCachedNode = (node) => {
+  if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
+    return node.codegenNode;
+  }
+};
 const dataAriaRE = /^(data|aria)-/;
 const isStringifiableAttr = (name, ns) => {
   return (ns === 0 ? isKnownHtmlAttr(name) : ns === 1 ? isKnownSvgAttr(name) : false) || dataAriaRE.test(name);
 };
-const replaceHoist = (node, replacement, context) => {
-  const hoistToReplace = node.codegenNode.hoisted;
-  context.hoists[context.hoists.indexOf(hoistToReplace)] = replacement;
-};
 const isNonStringifiable = /* @__PURE__ */ makeMap(
   `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
 );
@@ -25114,6 +25145,7 @@ function analyzeNode(node) {
     return false;
   };
   function walk(node2) {
+    const isOptionTag = node2.tag === "option" && node2.ns === 0;
     for (let i = 0; i < node2.props.length; i++) {
       const p = node2.props[i];
       if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
@@ -25126,6 +25158,9 @@ function analyzeNode(node) {
         if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
           return bail();
         }
+        if (isOptionTag && isStaticArgOf(p.arg, "value") && p.exp && p.exp.ast && p.exp.ast.type !== "StringLiteral") {
+          return bail();
+        }
       }
     }
     for (let i = 0; i < node2.children.length; i++) {
@@ -25267,12 +25302,10 @@ function isValidHTMLNesting(parent, child) {
     return onlyValidParents[child].has(parent);
   }
   if (parent in knownInvalidChildren) {
-    if (knownInvalidChildren[parent].has(child))
-      return false;
+    if (knownInvalidChildren[parent].has(child)) return false;
   }
   if (child in knownInvalidParents) {
-    if (knownInvalidParents[child].has(parent))
-      return false;
+    if (knownInvalidParents[child].has(parent)) return false;
   }
   return true;
 }
@@ -25886,8 +25919,7 @@ function resolveObjectKey(node, computed) {
     case "NumericLiteral":
       return String(node.value);
     case "Identifier":
-      if (!computed)
-        return node.name;
+      if (!computed) return node.name;
   }
   return void 0;
 }
@@ -25906,8 +25938,7 @@ function toRuntimeTypeString(types) {
 function getImportedName(specifier) {
   if (specifier.type === "ImportSpecifier")
     return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
-  else if (specifier.type === "ImportNamespaceSpecifier")
-    return "*";
+  else if (specifier.type === "ImportNamespaceSpecifier") return "*";
   return "default";
 }
 function getId(node) {
@@ -26274,8 +26305,8 @@ Item.prototype.run = function () {
 var title = 'browser';
 var platform = 'browser';
 var browser = true;
-var env = {};
-var argv = [];
+var env$1 = {};
+var argv$1 = [];
 var version$1 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
@@ -26338,8 +26369,8 @@ var browser$1 = {
   nextTick: nextTick,
   title: title,
   browser: browser,
-  env: env,
-  argv: argv,
+  env: env$1,
+  argv: argv$1,
   version: version$1,
   versions: versions,
   on: on,
@@ -26383,8 +26414,7 @@ function resolveTemplateUsedIdentifiers(sfc) {
     switch (node.type) {
       case 1:
         let tag = node.tag;
-        if (tag.includes("."))
-          tag = tag.split(".")[0].trim();
+        if (tag.includes(".")) tag = tag.split(".")[0].trim();
         if (!parserOptions.isNativeTag(tag) && !parserOptions.isBuiltInComponent(tag)) {
           ids.add(camelize(tag));
           ids.add(capitalize$1(camelize(tag)));
@@ -30801,11 +30831,9 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
     if (srcsetTags.includes(node.tag) && node.props.length) {
       node.props.forEach((attr, index) => {
         if (attr.name === "srcset" && attr.type === 6) {
-          if (!attr.value)
-            return;
+          if (!attr.value) return;
           const value = attr.value.content;
-          if (!value)
-            return;
+          if (!value) return;
           const imageCandidates = value.split(",").map((s) => {
             const [url, descriptor] = s.replace(escapedSpaceCharacters, " ").trim().split(" ", 2);
             return { url, descriptor };
@@ -32159,8 +32187,7 @@ const ssrInjectFallthroughAttrs = (node, context) => {
     let hasEncounteredIf = false;
     for (const c of filterChild(parent)) {
       if (c.type === 9 || c.type === 1 && findDir(c, "if")) {
-        if (hasEncounteredIf)
-          return;
+        if (hasEncounteredIf) return;
         hasEncounteredIf = true;
       } else if (
         // node before v-if
@@ -32302,6 +32329,10 @@ var CompilerSSR = /*#__PURE__*/Object.freeze({
   compile: compile
 });
 
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
 var _polyfillNode_fs = {};
 
 var _polyfillNode_fs$1 = /*#__PURE__*/Object.freeze({
@@ -32356,13 +32387,11 @@ function preprocess$1({ source, filename, preprocessOptions }, preprocessor) {
     source,
     __spreadValues$6({ filename }, preprocessOptions),
     (_err, _res) => {
-      if (_err)
-        err = _err;
+      if (_err) err = _err;
       res = _res;
     }
   );
-  if (err)
-    throw err;
+  if (err) throw err;
   return res;
 }
 function compileTemplate(options) {
@@ -32432,11 +32461,11 @@ function doCompileTemplate({
   }
   if (ssr && !ssrCssVars) {
     warnOnce$3(
-      `compileTemplate is called with \`ssr: true\` but no corresponding \`cssVars\` option.\`.`
+      `compileTemplate is called with \`ssr: true\` but no corresponding \`cssVars\` option.`
     );
   }
   if (!id) {
-    warnOnce$3(`compileTemplate now requires the \`id\` option.\`.`);
+    warnOnce$3(`compileTemplate now requires the \`id\` option.`);
     id = "";
   }
   const shortId = id.replace(/^data-v-/, "");
@@ -32497,10 +32526,8 @@ ${generateCodeFrame(
   return { code, ast, preamble, source, errors, tips, map };
 }
 function mapLines(oldMap, newMap) {
-  if (!oldMap)
-    return newMap;
-  if (!newMap)
-    return oldMap;
+  if (!oldMap) return newMap;
+  if (!newMap) return oldMap;
   const oldMapConsumer = new SourceMapConsumer$5(oldMap);
   const newMapConsumer = new SourceMapConsumer$5(newMap);
   const mergedMapGenerator = new SourceMapGenerator$6();
@@ -32592,15 +32619,15 @@ var _polyfillNode_tty$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_tty$1);
 
-let tty = require$$0;
-
+let argv = browser$1.argv || [],
+	env = ({});
 let isColorSupported =
-	!("NO_COLOR" in ({}) || browser$1.argv.includes("--no-color")) &&
-	("FORCE_COLOR" in ({}) ||
-		browser$1.argv.includes("--color") ||
+	!("NO_COLOR" in env || argv.includes("--no-color")) &&
+	("FORCE_COLOR" in env ||
+		argv.includes("--color") ||
 		"" === "win32" ||
-		(tty.isatty(1) && browser$1.env.TERM !== "dumb") ||
-		"CI" in ({}));
+		(commonjsRequire != null && require$$0.isatty(1) && env.TERM !== "dumb") ||
+		"CI" in env);
 
 let formatter =
 	(open, close, replace = open) =>
@@ -32613,40 +32640,47 @@ let formatter =
 	};
 
 let replaceClose = (string, close, replace, index) => {
-	let start = string.substring(0, index) + replace;
-	let end = string.substring(index + close.length);
-	let nextIndex = end.indexOf(close);
-	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
-};
-
-let createColors = (enabled = isColorSupported) => ({
-	isColorSupported: enabled,
-	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
-	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
-	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
-	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
-	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
-	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
-	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
-	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
-	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
-	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
-	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
-	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
-	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
-	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
-	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
-	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
-	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
-	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
-	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
-	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
-	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
-	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
-	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
-	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
-	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
-});
+	let result = "";
+	let cursor = 0;
+	do {
+		result += string.substring(cursor, index) + replace;
+		cursor = index + close.length;
+		index = string.indexOf(close, cursor);
+	} while (~index)
+	return result + string.substring(cursor)
+};
+
+let createColors = (enabled = isColorSupported) => {
+	let init = enabled ? formatter : () => String;
+	return {
+		isColorSupported: enabled,
+		reset: init("\x1b[0m", "\x1b[0m"),
+		bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: init("\x1b[3m", "\x1b[23m"),
+		underline: init("\x1b[4m", "\x1b[24m"),
+		inverse: init("\x1b[7m", "\x1b[27m"),
+		hidden: init("\x1b[8m", "\x1b[28m"),
+		strikethrough: init("\x1b[9m", "\x1b[29m"),
+		black: init("\x1b[30m", "\x1b[39m"),
+		red: init("\x1b[31m", "\x1b[39m"),
+		green: init("\x1b[32m", "\x1b[39m"),
+		yellow: init("\x1b[33m", "\x1b[39m"),
+		blue: init("\x1b[34m", "\x1b[39m"),
+		magenta: init("\x1b[35m", "\x1b[39m"),
+		cyan: init("\x1b[36m", "\x1b[39m"),
+		white: init("\x1b[37m", "\x1b[39m"),
+		gray: init("\x1b[90m", "\x1b[39m"),
+		bgBlack: init("\x1b[40m", "\x1b[49m"),
+		bgRed: init("\x1b[41m", "\x1b[49m"),
+		bgGreen: init("\x1b[42m", "\x1b[49m"),
+		bgYellow: init("\x1b[43m", "\x1b[49m"),
+		bgBlue: init("\x1b[44m", "\x1b[49m"),
+		bgMagenta: init("\x1b[45m", "\x1b[49m"),
+		bgCyan: init("\x1b[46m", "\x1b[49m"),
+		bgWhite: init("\x1b[47m", "\x1b[49m"),
+	}
+};
 
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
@@ -36718,7 +36752,7 @@ let Root$2 = root$2;
 
 let Processor$1 = class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.38';
+    this.version = '8.4.39';
     this.plugins = this.normalize(plugins);
   }
 
@@ -36965,10 +36999,8 @@ const trimPlugin = () => {
     Once(root) {
       root.walk(({ type, raws }) => {
         if (type === "rule" || type === "atrule") {
-          if (raws.before)
-            raws.before = "\n";
-          if ("after" in raws && raws.after)
-            raws.after = "\n";
+          if (raws.before) raws.before = "\n";
+          if ("after" in raws && raws.after) raws.after = "\n";
         }
       });
     }
@@ -39151,7 +39183,8 @@ tokenTypes.combinator = combinator$1;
 	          line: 1,
 	          column: 1
 	        }
-	      }
+	      },
+	      sourceIndex: 0
 	    });
 	    this.root.append(selector);
 	    this.current = selector;
@@ -39610,7 +39643,8 @@ tokenTypes.combinator = combinator$1;
 	    var selector = new _selector["default"]({
 	      source: {
 	        start: tokenStart(this.tokens[this.position + 1])
-	      }
+	      },
+	      sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
 	    });
 	    this.current.parent.append(selector);
 	    this.current = selector;
@@ -39679,8 +39713,9 @@ tokenTypes.combinator = combinator$1;
 	    if (last && last.type === types$1.PSEUDO) {
 	      var selector = new _selector["default"]({
 	        source: {
-	          start: tokenStart(this.tokens[this.position - 1])
-	        }
+	          start: tokenStart(this.tokens[this.position])
+	        },
+	        sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
 	      });
 	      var cache = this.current;
 	      last.append(selector);
@@ -40528,8 +40563,7 @@ function rewriteSelector(id, selector, selectorRoot, slotted = false) {
           return false;
         }
       }
-      if (node)
-        return;
+      if (node) return;
     }
     if (n.type !== "pseudo" && n.type !== "combinator" || n.type === "pseudo" && (n.value === ":is" || n.value === ":where") && !node) {
       node = n;
@@ -43859,8 +43893,7 @@ const less = (source, map, options, load = require) => {
       result = output;
     }
   );
-  if (error)
-    return { code: "", errors: [error], dependencies: [] };
+  if (error) return { code: "", errors: [error], dependencies: [] };
   const dependencies = result.imports;
   if (map) {
     return {
@@ -43880,8 +43913,7 @@ const styl = (source, map, options, load = require) => {
   const nodeStylus = load("stylus");
   try {
     const ref = nodeStylus(source, options);
-    if (map)
-      ref.set("sourcemap", { inline: false, comment: false });
+    if (map) ref.set("sourcemap", { inline: false, comment: false });
     const result = ref.render();
     const dependencies = ref.deps();
     if (map) {
@@ -43898,8 +43930,7 @@ const styl = (source, map, options, load = require) => {
   }
 };
 function getSource(source, filename, additionalData) {
-  if (!additionalData)
-    return source;
+  if (!additionalData) return source;
   if (isFunction$1(additionalData)) {
     return additionalData(source, filename);
   }
@@ -44099,11 +44130,9 @@ function analyzeBindingsFromOptions(node) {
 function getObjectExpressionKeys(node) {
   const keys = [];
   for (const prop of node.properties) {
-    if (prop.type === "SpreadElement")
-      continue;
+    if (prop.type === "SpreadElement") continue;
     const key = resolveObjectKey(prop.key, prop.computed);
-    if (key)
-      keys.push(String(key));
+    if (key) keys.push(String(key));
   }
   return keys;
 }
@@ -45551,12 +45580,12 @@ function resolveParserPlugins(lang, userPlugins, dts = false) {
   )) {
     plugins.push("importAttributes");
   }
-  if (lang === "jsx" || lang === "tsx") {
+  if (lang === "jsx" || lang === "tsx" || lang === "mtsx") {
     plugins.push("jsx");
   } else if (userPlugins) {
     userPlugins = userPlugins.filter((p) => p !== "jsx");
   }
-  if (lang === "ts" || lang === "tsx") {
+  if (lang === "ts" || lang === "mts" || lang === "tsx" || lang === "mtsx") {
     plugins.push(["typescript", { dts }], "explicitResourceManagement");
     if (!userPlugins || !userPlugins.includes("decorators")) {
       plugins.push("decorators-legacy");
@@ -45771,12 +45800,16 @@ function resolveTypeElements(ctx, node, scope, typeParameters) {
 }
 function innerResolveTypeElements(ctx, node, scope, typeParameters) {
   var _a, _b;
+  if (node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
+    return { props: {} };
+  }
   switch (node.type) {
     case "TSTypeLiteral":
       return typeElementsToMap(ctx, node.members, scope, typeParameters);
     case "TSInterfaceDeclaration":
       return resolveInterfaceMembers(ctx, node, scope, typeParameters);
     case "TSTypeAliasDeclaration":
+    case "TSTypeAnnotation":
     case "TSParenthesizedType":
       return resolveTypeElements(
         ctx,
@@ -45794,7 +45827,7 @@ function innerResolveTypeElements(ctx, node, scope, typeParameters) {
         node.type
       );
     case "TSMappedType":
-      return resolveMappedType(ctx, node, scope);
+      return resolveMappedType(ctx, node, scope, typeParameters);
     case "TSIndexedAccessType": {
       const types = resolveIndexType(ctx, node, scope);
       return mergeElements(
@@ -45823,8 +45856,7 @@ function innerResolveTypeElements(ctx, node, scope, typeParameters) {
           typeParams = /* @__PURE__ */ Object.create(null);
           resolved.typeParameters.params.forEach((p, i) => {
             let param = typeParameters && typeParameters[p.name];
-            if (!param)
-              param = node.typeParameters.params[i];
+            if (!param) param = node.typeParameters.params[i];
             typeParams[p.name] = param;
           });
         }
@@ -45934,8 +45966,7 @@ function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx), typeParameter
   return res;
 }
 function mergeElements(maps, type) {
-  if (maps.length === 1)
-    return maps[0];
+  if (maps.length === 1) return maps[0];
   const res = { props: {} };
   const { props: baseProps } = res;
   for (const { props, calls } of maps) {
@@ -45983,9 +46014,6 @@ function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
   );
   if (node.extends) {
     for (const ext of node.extends) {
-      if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
-        continue;
-      }
       try {
         const { props, calls } = resolveTypeElements(ctx, ext, scope);
         for (const key in props) {
@@ -46005,16 +46033,25 @@ If this previously worked in 3.2, you can instruct the compiler to ignore this e
 interface Props extends /* @vue-ignore */ Base {}
 
 Note: both in 3.2 or with the ignore, the properties in the base type are treated as fallthrough attrs at runtime.`,
-          ext
+          ext,
+          scope
         );
       }
     }
   }
   return base;
 }
-function resolveMappedType(ctx, node, scope) {
+function resolveMappedType(ctx, node, scope, typeParameters) {
   const res = { props: {} };
-  const keys = resolveStringType(ctx, node.typeParameter.constraint, scope);
+  let keys;
+  if (node.nameType) {
+    const { name, constraint } = node.typeParameter;
+    scope = createChildScope(scope);
+    Object.assign(scope.types, __spreadProps$1(__spreadValues$2({}, typeParameters), { [name]: constraint }));
+    keys = resolveStringType(ctx, node.nameType, scope);
+  } else {
+    keys = resolveStringType(ctx, node.typeParameter.constraint, scope);
+  }
   for (const key of keys) {
     res.props[key] = createProperty(
       {
@@ -46358,7 +46395,7 @@ function importSourceToScope(ctx, node, scope, source) {
       const osSpecificJoinFn = joinPaths;
       const filename = osSpecificJoinFn(dirname$2(scope.filename), source);
       resolved = resolveExt(filename, fs);
-    } else if (source.startsWith(".")) {
+    } else if (source[0] === ".") {
       const filename = joinPaths(dirname$2(scope.filename), source);
       resolved = resolveExt(filename, fs);
     } else {
@@ -46388,8 +46425,7 @@ function importSourceToScope(ctx, node, scope, source) {
 function resolveExt(filename, fs) {
   filename = filename.replace(/\.js$/, "");
   const tryResolve = (filename2) => {
-    if (fs.fileExists(filename2))
-      return filename2;
+    if (fs.fileExists(filename2)) return filename2;
   };
   return tryResolve(filename) || tryResolve(filename + `.ts`) || tryResolve(filename + `.tsx`) || tryResolve(filename + `.d.ts`) || tryResolve(joinPaths(filename, `index.ts`)) || tryResolve(joinPaths(filename, `index.tsx`)) || tryResolve(joinPaths(filename, `index.d.ts`));
 }
@@ -46401,8 +46437,7 @@ function invalidateTypeCache(filename) {
   fileToScopeCache.delete(filename);
   tsConfigCache.delete(filename);
   const affectedConfig = tsConfigRefMap.get(filename);
-  if (affectedConfig)
-    tsConfigCache.delete(affectedConfig);
+  if (affectedConfig) tsConfigCache.delete(affectedConfig);
 }
 function fileToScope(ctx, filename, asGlobal = false) {
   const cached = fileToScopeCache.get(filename);
@@ -46419,12 +46454,12 @@ function fileToScope(ctx, filename, asGlobal = false) {
 }
 function parseFile(filename, content, parserPlugins) {
   const ext = extname(filename);
-  if (ext === ".ts" || ext === ".tsx") {
+  if (ext === ".ts" || ext === ".mts" || ext === ".tsx" || ext === ".mtsx") {
     return parse_1$1(content, {
       plugins: resolveParserPlugins(
         ext.slice(1),
         parserPlugins,
-        filename.endsWith(".d.ts")
+        /\.d\.m?ts$/.test(filename)
       ),
       sourceType: "module"
     }).program.body;
@@ -46565,8 +46600,7 @@ function recordTypes(ctx, body, scope, asGlobal = false) {
   for (const key of Object.keys(types)) {
     const node = types[key];
     node._ownerScope = scope;
-    if (node._ns)
-      node._ns._ownerScope = scope;
+    if (node._ns) node._ns._ownerScope = scope;
   }
   for (const key of Object.keys(declares)) {
     declares[key]._ownerScope = scope;
@@ -46607,15 +46641,13 @@ function recordType(node, types, declares, overwriteId) {
       break;
     }
     case "ClassDeclaration":
-      if (overwriteId || node.id)
-        types[overwriteId || getId(node.id)] = node;
+      if (overwriteId || node.id) types[overwriteId || getId(node.id)] = node;
       break;
     case "TSTypeAliasDeclaration":
       types[node.id.name] = node.typeParameters ? node : node.typeAnnotation;
       break;
     case "TSDeclareFunction":
-      if (node.id)
-        declares[node.id.name] = node;
+      if (node.id) declares[node.id.name] = node;
       break;
     case "VariableDeclaration": {
       if (node.declare) {
@@ -46679,7 +46711,7 @@ function recordImport(node, imports) {
     };
   }
 }
-function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)) {
+function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx), isKeyOf = false) {
   try {
     switch (node.type) {
       case "TSStringKeyword":
@@ -46697,13 +46729,30 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         const types = /* @__PURE__ */ new Set();
         const members = node.type === "TSTypeLiteral" ? node.members : node.body.body;
         for (const m of members) {
-          if (m.type === "TSCallSignatureDeclaration" || m.type === "TSConstructSignatureDeclaration") {
+          if (isKeyOf) {
+            if (m.type === "TSPropertySignature" && m.key.type === "NumericLiteral") {
+              types.add("Number");
+            } else if (m.type === "TSIndexSignature") {
+              const annotation = m.parameters[0].typeAnnotation;
+              if (annotation && annotation.type !== "Noop") {
+                const type = inferRuntimeType(
+                  ctx,
+                  annotation.typeAnnotation,
+                  scope
+                )[0];
+                if (type === UNKNOWN_TYPE) return [UNKNOWN_TYPE];
+                types.add(type);
+              }
+            } else {
+              types.add("String");
+            }
+          } else if (m.type === "TSCallSignatureDeclaration" || m.type === "TSConstructSignatureDeclaration") {
             types.add("Function");
           } else {
             types.add("Object");
           }
         }
-        return types.size ? Array.from(types) : ["Object"];
+        return types.size ? Array.from(types) : [isKeyOf ? UNKNOWN_TYPE : "Object"];
       }
       case "TSPropertySignature":
         if (node.typeAnnotation) {
@@ -46735,70 +46784,121 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       case "TSTypeReference": {
         const resolved = resolveTypeReference(ctx, node, scope);
         if (resolved) {
-          return inferRuntimeType(ctx, resolved, resolved._ownerScope);
+          return inferRuntimeType(ctx, resolved, resolved._ownerScope, isKeyOf);
         }
         if (node.typeName.type === "Identifier") {
-          switch (node.typeName.name) {
-            case "Array":
-            case "Function":
-            case "Object":
-            case "Set":
-            case "Map":
-            case "WeakSet":
-            case "WeakMap":
-            case "Date":
-            case "Promise":
-            case "Error":
-              return [node.typeName.name];
-            case "Partial":
-            case "Required":
-            case "Readonly":
-            case "Record":
-            case "Pick":
-            case "Omit":
-            case "InstanceType":
-              return ["Object"];
-            case "Uppercase":
-            case "Lowercase":
-            case "Capitalize":
-            case "Uncapitalize":
-              return ["String"];
-            case "Parameters":
-            case "ConstructorParameters":
-            case "ReadonlyArray":
-              return ["Array"];
-            case "ReadonlyMap":
-              return ["Map"];
-            case "ReadonlySet":
-              return ["Set"];
-            case "NonNullable":
-              if (node.typeParameters && node.typeParameters.params[0]) {
-                return inferRuntimeType(
-                  ctx,
-                  node.typeParameters.params[0],
-                  scope
-                ).filter((t) => t !== "null");
-              }
-              break;
-            case "Extract":
-              if (node.typeParameters && node.typeParameters.params[1]) {
-                return inferRuntimeType(
-                  ctx,
-                  node.typeParameters.params[1],
-                  scope
-                );
-              }
-              break;
-            case "Exclude":
-            case "OmitThisParameter":
-              if (node.typeParameters && node.typeParameters.params[0]) {
-                return inferRuntimeType(
-                  ctx,
-                  node.typeParameters.params[0],
-                  scope
-                );
-              }
-              break;
+          if (isKeyOf) {
+            switch (node.typeName.name) {
+              case "String":
+              case "Array":
+              case "ArrayLike":
+              case "Parameters":
+              case "ConstructorParameters":
+              case "ReadonlyArray":
+                return ["String", "Number"];
+              case "Record":
+              case "Partial":
+              case "Required":
+              case "Readonly":
+                if (node.typeParameters && node.typeParameters.params[0]) {
+                  return inferRuntimeType(
+                    ctx,
+                    node.typeParameters.params[0],
+                    scope,
+                    true
+                  );
+                }
+                break;
+              case "Pick":
+              case "Extract":
+                if (node.typeParameters && node.typeParameters.params[1]) {
+                  return inferRuntimeType(
+                    ctx,
+                    node.typeParameters.params[1],
+                    scope
+                  );
+                }
+                break;
+              case "Function":
+              case "Object":
+              case "Set":
+              case "Map":
+              case "WeakSet":
+              case "WeakMap":
+              case "Date":
+              case "Promise":
+              case "Error":
+              case "Uppercase":
+              case "Lowercase":
+              case "Capitalize":
+              case "Uncapitalize":
+              case "ReadonlyMap":
+              case "ReadonlySet":
+                return ["String"];
+            }
+          } else {
+            switch (node.typeName.name) {
+              case "Array":
+              case "Function":
+              case "Object":
+              case "Set":
+              case "Map":
+              case "WeakSet":
+              case "WeakMap":
+              case "Date":
+              case "Promise":
+              case "Error":
+                return [node.typeName.name];
+              case "Partial":
+              case "Required":
+              case "Readonly":
+              case "Record":
+              case "Pick":
+              case "Omit":
+              case "InstanceType":
+                return ["Object"];
+              case "Uppercase":
+              case "Lowercase":
+              case "Capitalize":
+              case "Uncapitalize":
+                return ["String"];
+              case "Parameters":
+              case "ConstructorParameters":
+              case "ReadonlyArray":
+                return ["Array"];
+              case "ReadonlyMap":
+                return ["Map"];
+              case "ReadonlySet":
+                return ["Set"];
+              case "NonNullable":
+                if (node.typeParameters && node.typeParameters.params[0]) {
+                  return inferRuntimeType(
+                    ctx,
+                    node.typeParameters.params[0],
+                    scope
+                  ).filter((t) => t !== "null");
+                }
+                break;
+              case "Extract":
+                if (node.typeParameters && node.typeParameters.params[1]) {
+                  return inferRuntimeType(
+                    ctx,
+                    node.typeParameters.params[1],
+                    scope
+                  );
+                }
+                break;
+              case "Exclude":
+              case "OmitThisParameter":
+                if (node.typeParameters && node.typeParameters.params[0]) {
+                  return inferRuntimeType(
+                    ctx,
+                    node.typeParameters.params[0],
+                    scope
+                  );
+                }
+                break;
+            }
           }
         }
         break;
@@ -46806,9 +46906,9 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       case "TSParenthesizedType":
         return inferRuntimeType(ctx, node.typeAnnotation, scope);
       case "TSUnionType":
-        return flattenTypes(ctx, node.types, scope);
+        return flattenTypes(ctx, node.types, scope, isKeyOf);
       case "TSIntersectionType": {
-        return flattenTypes(ctx, node.types, scope).filter(
+        return flattenTypes(ctx, node.types, scope, isKeyOf).filter(
           (t) => t !== UNKNOWN_TYPE
         );
       }
@@ -46840,27 +46940,38 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         if (id.type === "Identifier") {
           const matched = scope.declares[id.name];
           if (matched) {
-            return inferRuntimeType(ctx, matched, matched._ownerScope);
+            return inferRuntimeType(ctx, matched, matched._ownerScope, isKeyOf);
           }
         }
         break;
       }
       case "TSTypeOperator": {
-        return inferRuntimeType(ctx, node.typeAnnotation, scope);
+        return inferRuntimeType(
+          ctx,
+          node.typeAnnotation,
+          scope,
+          node.operator === "keyof"
+        );
+      }
+      case "TSAnyKeyword": {
+        if (isKeyOf) {
+          return ["String", "Number", "Symbol"];
+        }
+        break;
       }
     }
   } catch (e) {
   }
   return [UNKNOWN_TYPE];
 }
-function flattenTypes(ctx, types, scope) {
+function flattenTypes(ctx, types, scope, isKeyOf = false) {
   if (types.length === 1) {
-    return inferRuntimeType(ctx, types[0], scope);
+    return inferRuntimeType(ctx, types[0], scope, isKeyOf);
   }
   return [
     ...new Set(
       [].concat(
-        ...types.map((t) => inferRuntimeType(ctx, t, scope))
+        ...types.map((t) => inferRuntimeType(ctx, t, scope, isKeyOf))
       )
     )
   ];
@@ -46916,8 +47027,7 @@ function reverseInferType(key, node, scope, optional = true, checkObjectSyntax =
   if ((node.type === "TSTypeReference" || node.type === "TSImportType") && node.typeParameters) {
     for (const t of node.typeParameters.params) {
       const inferred = reverseInferType(key, t, scope, optional);
-      if (inferred)
-        return inferred;
+      if (inferred) return inferred;
     }
   }
   return createProperty(key, { type: `TSNullKeyword` }, scope, optional);
@@ -46957,8 +47067,7 @@ function resolveReturnType(ctx, arg, scope) {
   if (arg.type === "TSTypeReference" || arg.type === "TSTypeQuery" || arg.type === "TSImportType") {
     resolved = resolveTypeReference(ctx, arg, scope);
   }
-  if (!resolved)
-    return;
+  if (!resolved) return;
   if (resolved.type === "TSFunctionType") {
     return (_a = resolved.typeAnnotation) == null ? void 0 : _a.typeAnnotation;
   }
@@ -46969,8 +47078,7 @@ function resolveReturnType(ctx, arg, scope) {
 function resolveUnionType(ctx, node, scope) {
   if (node.type === "TSTypeReference") {
     const resolved = resolveTypeReference(ctx, node, scope);
-    if (resolved)
-      node = resolved;
+    if (resolved) node = resolved;
   }
   let types;
   if (node.type === "TSUnionType") {
@@ -47047,8 +47155,7 @@ function processDefineModel(ctx, node, declId) {
   return true;
 }
 function genModelProps(ctx) {
-  if (!ctx.hasDefineModelCall)
-    return;
+  if (!ctx.hasDefineModelCall) return;
   const isProd = !!ctx.options.isProd;
   let modelPropsDecl = "";
   for (const [name, { type, options: runtimeOptions }] of Object.entries(
@@ -47250,8 +47357,7 @@ function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStat
   } else if (hasStaticDefaults) {
     const prop = ctx.propsRuntimeDefaults.properties.find(
       (node) => {
-        if (node.type === "SpreadElement")
-          return false;
+        if (node.type === "SpreadElement") return false;
         return resolveObjectKey(node.key, node.computed) === key;
       }
     );
@@ -47421,8 +47527,7 @@ function transformDestructuredProps(ctx, vueImportAliases) {
       if (stmt.type === "VariableDeclaration") {
         walkVariableDeclaration(stmt, isRoot);
       } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
-        if (stmt.declare || !stmt.id)
-          continue;
+        if (stmt.declare || !stmt.id) continue;
         registerLocalBinding(stmt.id);
       } else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
         walkVariableDeclaration(stmt.left);
@@ -47648,8 +47753,7 @@ function processDefineOptions(ctx, node) {
   if (node.typeParameters) {
     ctx.error(`${DEFINE_OPTIONS}() cannot accept type arguments`, node);
   }
-  if (!node.arguments[0])
-    return true;
+  if (!node.arguments[0]) return true;
   ctx.hasDefineOptionsCall = true;
   ctx.optionsRuntimeDecl = unwrapTSNode(node.arguments[0]);
   let propsOption = void 0;
@@ -47659,14 +47763,20 @@ function processDefineOptions(ctx, node) {
   if (ctx.optionsRuntimeDecl.type === "ObjectExpression") {
     for (const prop of ctx.optionsRuntimeDecl.properties) {
       if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
-        if (prop.key.name === "props")
-          propsOption = prop;
-        if (prop.key.name === "emits")
-          emitsOption = prop;
-        if (prop.key.name === "expose")
-          exposeOption = prop;
-        if (prop.key.name === "slots")
-          slotsOption = prop;
+        switch (prop.key.name) {
+          case "props":
+            propsOption = prop;
+            break;
+          case "emits":
+            emitsOption = prop;
+            break;
+          case "expose":
+            exposeOption = prop;
+            break;
+          case "slots":
+            slotsOption = prop;
+            break;
+        }
       }
     }
   }
@@ -47742,6 +47852,15 @@ var __spreadValues$1 = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const MACROS = [
+  DEFINE_PROPS,
+  DEFINE_EMITS,
+  DEFINE_EXPOSE,
+  DEFINE_OPTIONS,
+  DEFINE_SLOTS,
+  DEFINE_MODEL,
+  WITH_DEFAULTS
+];
 function compileScript(sfc, options) {
   var _a, _b, _c;
   if (!options.id) {
@@ -47809,8 +47928,7 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
     };
   }
   function checkInvalidScopeReference(node, method) {
-    if (!node)
-      return;
+    if (!node) return;
     walkIdentifiers(node, (id) => {
       const binding = setupBindings[id.name];
       if (binding && binding !== "literal-const") {
@@ -47860,10 +47978,17 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
         const imported = getImportedName(specifier);
         const source2 = node.source.value;
         const existing = ctx.userImports[local];
-        if (source2 === "vue" && (imported === DEFINE_PROPS || imported === DEFINE_EMITS || imported === DEFINE_EXPOSE)) {
-          warnOnce$3(
-            `\`${imported}\` is a compiler macro and no longer needs to be imported.`
-          );
+        if (source2 === "vue" && MACROS.includes(imported)) {
+          if (local === imported) {
+            warnOnce$3(
+              `\`${imported}\` is a compiler macro and no longer needs to be imported.`
+            );
+          } else {
+            ctx.error(
+              `\`${imported}\` is a compiler macro and cannot be aliased to a different name.`,
+              specifier
+            );
+          }
           removeSpecifier(i);
         } else if (existing) {
           if (existing.source === source2 && existing.imported === imported) {
@@ -47893,8 +48018,7 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
   const vueImportAliases = {};
   for (const key in ctx.userImports) {
     const { source: source2, imported, local } = ctx.userImports[key];
-    if (source2 === "vue")
-      vueImportAliases[imported] = local;
+    if (source2 === "vue") vueImportAliases[imported] = local;
   }
   if (script && scriptAst) {
     for (const node of scriptAst.body) {
@@ -48008,6 +48132,9 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
             );
           }
           const isDefineProps = processDefineProps(ctx, init, decl.id);
+          if (ctx.propsDestructureRestId) {
+            setupBindings[ctx.propsDestructureRestId] = "setup-reactive-const";
+          }
           const isDefineEmits = !isDefineProps && processDefineEmits(ctx, init, decl.id);
           !isDefineEmits && (processDefineSlots(ctx, init, decl.id) || processDefineModel(ctx, init, decl.id));
           if (isDefineProps && !ctx.propsDestructureRestId && ctx.propsDestructureDecl) {
@@ -48043,7 +48170,8 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
         node,
         setupBindings,
         vueImportAliases,
-        hoistStatic
+        hoistStatic,
+        !!ctx.propsDestructureDecl
       );
     }
     if (hoistStatic && isAllLiteral) {
@@ -48074,8 +48202,7 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
           }
         },
         exit(node2) {
-          if (node2.type === "BlockStatement")
-            scope.pop();
+          if (node2.type === "BlockStatement") scope.pop();
         }
       });
     }
@@ -48126,8 +48253,7 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
   for (const [key, { isType, imported, source: source2 }] of Object.entries(
     ctx.userImports
   )) {
-    if (isType)
-      continue;
+    if (isType) continue;
     ctx.bindingMetadata[key] = imported === "*" || imported === "default" && source2.endsWith(".vue") || source2 === "vue" ? "setup-const" : "setup-maybe-ref";
   }
   for (const key in scriptBindings) {
@@ -48294,12 +48420,10 @@ return ${returned}
   __ssrInlineRender: true,`;
   }
   const propsDecl = genRuntimeProps(ctx);
-  if (propsDecl)
-    runtimeOptions += `
+  if (propsDecl) runtimeOptions += `
   props: ${propsDecl},`;
   const emitsDecl = genRuntimeEmits(ctx);
-  if (emitsDecl)
-    runtimeOptions += `
+  if (emitsDecl) runtimeOptions += `
   emits: ${emitsDecl},`;
   let definedOptions = "";
   if (ctx.optionsRuntimeDecl) {
@@ -48367,7 +48491,7 @@ ${exposeCall}`
 function registerBinding(bindings, node, type) {
   bindings[node.name] = type;
 }
-function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
+function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic, isPropsDestructureEnabled = false) {
   let isAllLiteral = false;
   if (node.type === "VariableDeclaration") {
     const isConst = node.kind === "const";
@@ -48376,10 +48500,10 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
     );
     for (const { id, init: _init } of node.declarations) {
       const init = _init && unwrapTSNode(_init);
-      const isDefineCall = !!(isConst && isCallOf(
+      const isConstMacroCall = isConst && isCallOf(
         init,
-        (c) => c === DEFINE_PROPS || c === DEFINE_EMITS || c === WITH_DEFAULTS
-      ));
+        (c) => c === DEFINE_PROPS || c === DEFINE_EMITS || c === WITH_DEFAULTS || c === DEFINE_SLOTS
+      );
       if (id.type === "Identifier") {
         let bindingType;
         const userReactiveBinding = userImportAliases["reactive"];
@@ -48390,7 +48514,7 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
         } else if (
           // if a declaration is a const literal, we can mark it so that
           // the generated render fn code doesn't need to unref() it
-          isDefineCall || isConst && canNeverBeRef(init, userReactiveBinding)
+          isConstMacroCall || isConst && canNeverBeRef(init, userReactiveBinding)
         ) {
           bindingType = isCallOf(init, DEFINE_PROPS) ? "setup-reactive-const" : "setup-const";
         } else if (isConst) {
@@ -48407,13 +48531,13 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
         }
         registerBinding(bindings, id, bindingType);
       } else {
-        if (isCallOf(init, DEFINE_PROPS)) {
+        if (isCallOf(init, DEFINE_PROPS) && isPropsDestructureEnabled) {
           continue;
         }
         if (id.type === "ObjectPattern") {
-          walkObjectPattern(id, bindings, isConst, isDefineCall);
+          walkObjectPattern(id, bindings, isConst, isConstMacroCall);
         } else if (id.type === "ArrayPattern") {
-          walkArrayPattern(id, bindings, isConst, isDefineCall);
+          walkArrayPattern(id, bindings, isConst, isConstMacroCall);
         }
       }
     }
@@ -48536,7 +48660,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.0-alpha.2";
+const version = "3.5.0-alpha.3";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;