@vue/compiler-sfc 3.4.26 → 3.4.28

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

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.26
+* @vue/compiler-sfc v3.4.28
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -91,6 +91,9 @@ 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};`;
     }
   }
@@ -2146,8 +2148,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 +2448,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 +2659,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 +2949,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 +3017,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 +3031,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 +3105,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 +4008,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 +4232,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 +4249,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 +7136,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 +7501,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 +7538,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 +8922,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 +9084,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 +9141,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 +9222,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 +9538,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 +11396,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 +11575,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 +11686,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 +11887,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 +12241,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 +12306,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 +12341,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 +12469,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 +12495,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 +12512,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 +12532,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 +13660,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 +13706,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 +13759,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 +13898,6 @@ class ExpressionParser extends LValParser {
         prop.computed = false;
       }
     }
-    return prop.key;
   }
   initFunction(node, isAsync) {
     node.id = null;
@@ -15322,8 +15307,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 +15413,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 +15445,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 +15463,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 +15477,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 +15509,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 +15529,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 +15540,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 +15677,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 +15689,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 +15807,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 +15852,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 +16570,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 +16662,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 +16706,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 +16859,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 +16980,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;
       }
@@ -17147,7 +17144,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 +17297,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 +17329,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 +17474,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 +17603,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"]);
@@ -17929,7 +17920,7 @@ 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);
@@ -18227,8 +18218,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}`,
@@ -18315,8 +18305,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 +18376,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 +21815,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 +21835,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,
@@ -22064,8 +22050,9 @@ function genHoists(hoists, context) {
   const genScopeId = scopeId != null && mode !== "function";
   newline();
   if (genScopeId) {
+    const param = context.isTS ? "(n: any)" : "n";
     push(
-      `const _withScopeId = n => (${helper(
+      `const _withScopeId = ${param} => (${helper(
         PUSH_SCOPE_ID
       )}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
     );
@@ -22229,8 +22216,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(`)`);
@@ -22310,8 +22296,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`);
 }
@@ -22454,11 +22439,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("}");
     }
   }
@@ -22829,8 +22812,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(
@@ -22952,6 +22934,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 +23028,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(
@@ -23137,13 +23206,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 +23246,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));
 }
@@ -23448,13 +23514,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;
     }
   }
@@ -23490,7 +23554,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(
@@ -23613,8 +23677,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 +23761,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 +24077,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 +24107,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 +24204,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 +24307,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 () => {
@@ -24944,8 +24925,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")) {
@@ -25114,6 +25094,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 +25107,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++) {
@@ -25712,8 +25696,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;
 }
@@ -25732,8 +25715,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) {
@@ -26100,8 +26082,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 = {};
@@ -26164,8 +26146,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,
@@ -26209,8 +26191,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)));
@@ -30627,11 +30608,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 };
@@ -31985,8 +31964,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
@@ -32128,6 +32106,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({
@@ -32182,13 +32164,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) {
@@ -32258,11 +32238,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-/, "");
@@ -32323,10 +32303,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();
@@ -32418,15 +32396,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) =>
@@ -32439,40 +32417,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;
@@ -36791,10 +36776,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";
         }
       });
     }
@@ -37220,7 +37203,7 @@ types.UNIVERSAL = UNIVERSAL;
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 	function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike  ) { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 	function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-	function _arrayLikeToArray(arr, len) { len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+	function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
@@ -38977,7 +38960,8 @@ tokenTypes.combinator = combinator$1;
 	          line: 1,
 	          column: 1
 	        }
-	      }
+	      },
+	      sourceIndex: 0
 	    });
 	    this.root.append(selector);
 	    this.current = selector;
@@ -39436,7 +39420,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;
@@ -39505,8 +39490,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);
@@ -40354,8 +40340,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;
@@ -43685,8 +43670,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 {
@@ -43706,8 +43690,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) {
@@ -43724,8 +43707,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);
   }
@@ -43925,11 +43907,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;
 }
@@ -45620,7 +45600,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(
@@ -45649,8 +45629,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;
           });
         }
@@ -45760,8 +45739,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) {
@@ -45838,9 +45816,17 @@ Note: both in 3.2 or with the ignore, the properties in the base type are treate
   }
   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(
       {
@@ -46184,7 +46170,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 {
@@ -46214,8 +46200,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`));
 }
@@ -46227,8 +46212,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);
@@ -46391,8 +46375,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;
@@ -46433,15 +46416,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) {
@@ -46505,7 +46486,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":
@@ -46523,13 +46504,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) {
@@ -46561,70 +46559,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;
@@ -46632,9 +46681,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
         );
       }
@@ -46666,27 +46715,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))
       )
     )
   ];
@@ -46742,8 +46802,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);
@@ -46783,8 +46842,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;
   }
@@ -46795,8 +46853,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") {
@@ -46873,8 +46930,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(
@@ -47076,8 +47132,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;
       }
     );
@@ -47249,8 +47304,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);
@@ -47476,8 +47530,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;
@@ -47487,14 +47540,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;
+        }
       }
     }
   }
@@ -47570,6 +47629,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) {
@@ -47637,8 +47705,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") {
@@ -47688,10 +47755,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) {
@@ -47721,8 +47795,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) {
@@ -47836,6 +47909,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) {
@@ -47902,8 +47978,7 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
           }
         },
         exit(node2) {
-          if (node2.type === "BlockStatement")
-            scope.pop();
+          if (node2.type === "BlockStatement") scope.pop();
         }
       });
     }
@@ -47954,8 +48029,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) {
@@ -48122,12 +48196,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) {
@@ -48204,10 +48276,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"];
@@ -48218,7 +48290,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) {
@@ -48239,9 +48311,9 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
           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);
         }
       }
     }
@@ -48364,7 +48436,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.4.26";
+const version = "3.4.28";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;