@vue/compiler-sfc 3.4.26 → 3.4.28

package/dist/compiler-sfc.cjs.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
 **/
@@ -44,8 +44,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;
 }
@@ -64,8 +63,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) {
@@ -1764,8 +1762,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 (!CompilerDOM.parserOptions.isNativeTag(tag) && !CompilerDOM.parserOptions.isBuiltInComponent(tag)) {
           ids.add(shared.camelize(tag));
           ids.add(shared.capitalize(shared.camelize(tag)));
@@ -2257,11 +2254,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 };
@@ -4192,13 +4187,11 @@ function preprocess$1({ source, filename, preprocessOptions }, preprocessor) {
     source,
     { 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) {
@@ -4264,11 +4257,11 @@ function doCompileTemplate({
   }
   if (ssr && !ssrCssVars) {
     warnOnce(
-      `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(`compileTemplate now requires the \`id\` option.\`.`);
+    warnOnce(`compileTemplate now requires the \`id\` option.`);
     id = "";
   }
   const shortId = id.replace(/^data-v-/, "");
@@ -4329,10 +4322,8 @@ ${shared.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 sourceMapJs.SourceMapConsumer(oldMap);
   const newMapConsumer = new sourceMapJs.SourceMapConsumer(newMap);
   const mergedMapGenerator = new sourceMapJs.SourceMapGenerator();
@@ -4397,10 +4388,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";
         }
       });
     }
@@ -4826,7 +4815,7 @@ types$1.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); }
@@ -6583,7 +6572,8 @@ tokenTypes.combinator = combinator$1;
 	          line: 1,
 	          column: 1
 	        }
-	      }
+	      },
+	      sourceIndex: 0
 	    });
 	    this.root.append(selector);
 	    this.current = selector;
@@ -7042,7 +7032,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;
@@ -7111,8 +7102,9 @@ tokenTypes.combinator = combinator$1;
 	    if (last && last.type === types.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);
@@ -7960,8 +7952,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;
@@ -11274,8 +11265,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 {
@@ -11295,8 +11285,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) {
@@ -11313,8 +11302,7 @@ const styl = (source, map, options, load = require) => {
   }
 };
 function getSource(source, filename, additionalData) {
-  if (!additionalData)
-    return source;
+  if (!additionalData) return source;
   if (shared.isFunction(additionalData)) {
     return additionalData(source, filename);
   }
@@ -12000,6 +11988,10 @@ var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
 function baseSlice(array, start, end) {
   var index = -1,
       length = array.length;
+
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
   end = end > length ? length : end;
   if (end < 0) {
     end += length;
@@ -12046,7 +12038,7 @@ function baseToString(value) {
 function castSlice(array, start, end) {
   var length = array.length;
   end = end === undefined ? length : end;
-  return baseSlice(array, start, end);
+  return (!start && end >= length) ? array : baseSlice(array, start, end);
 }
 
 /**
@@ -15600,11 +15592,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;
 }
@@ -17964,7 +17954,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(
@@ -17993,8 +17983,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;
           });
         }
@@ -18104,8 +18093,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) {
@@ -18182,9 +18170,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, { ...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(
       {
@@ -18529,13 +18525,12 @@ function importSourceToScope(ctx, node, scope, source) {
       const osSpecificJoinFn = process__namespace.platform === "win32" ? path$3.join : joinPaths;
       const filename = osSpecificJoinFn(path$3.dirname(scope.filename), source);
       resolved = resolveExt(filename, fs);
-    } else if (source.startsWith(".")) {
+    } else if (source[0] === ".") {
       const filename = joinPaths(path$3.dirname(scope.filename), source);
       resolved = resolveExt(filename, fs);
     } else {
       if (!ts) {
-        if (loadTS)
-          ts = loadTS();
+        if (loadTS) ts = loadTS();
         if (!ts) {
           return ctx.error(
             `Failed to resolve import source ${JSON.stringify(source)}. typescript is required as a peer dep for vue in order to support resolving types from module imports.`,
@@ -18564,8 +18559,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`));
 }
@@ -18596,7 +18590,7 @@ function resolveWithTS(containingFile, source, ts2, fs) {
         );
         const included = (_a = c.config.raw) == null ? void 0 : _a.include;
         const excluded = (_b = c.config.raw) == null ? void 0 : _b.exclude;
-        if (!included && (!base || containingFile.startsWith(base)) || included.some((p) => minimatch(containingFile, joinPaths(base, p)))) {
+        if (!included && (!base || containingFile.startsWith(base)) || (included == null ? void 0 : included.some((p) => minimatch(containingFile, joinPaths(base, p))))) {
           if (excluded && excluded.some((p) => minimatch(containingFile, joinPaths(base, p)))) {
             continue;
           }
@@ -18644,8 +18638,12 @@ function loadTSConfig(configPath, ts2, fs) {
   const res = [config];
   if (config.projectReferences) {
     for (const ref of config.projectReferences) {
-      tsConfigRefMap.set(ref.path, configPath);
-      res.unshift(...loadTSConfig(ref.path, ts2, fs));
+      const refPath = ts2.resolveProjectReferencePath(ref);
+      if (!fs.fileExists(refPath)) {
+        continue;
+      }
+      tsConfigRefMap.set(refPath, configPath);
+      res.unshift(...loadTSConfig(refPath, ts2, fs));
     }
   }
   return res;
@@ -18656,8 +18654,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);
@@ -18820,8 +18817,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;
@@ -18862,15 +18858,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) {
@@ -18934,7 +18928,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":
@@ -18952,13 +18946,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) {
@@ -18990,70 +19001,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;
@@ -19061,9 +19123,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
         );
       }
@@ -19095,27 +19157,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))
       )
     )
   ];
@@ -19171,8 +19244,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);
@@ -19212,8 +19284,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;
   }
@@ -19224,8 +19295,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") {
@@ -19302,8 +19372,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(
@@ -19505,8 +19574,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;
       }
     );
@@ -19678,8 +19746,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);
@@ -19905,8 +19972,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 = CompilerDOM.unwrapTSNode(node.arguments[0]);
   let propsOption = void 0;
@@ -19916,14 +19982,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;
+        }
       }
     }
   }
@@ -19980,6 +20052,15 @@ function processAwait(ctx, node, needSemi, isStatement) {
   );
 }
 
+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) {
@@ -20047,8 +20128,7 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
     };
   }
   function checkInvalidScopeReference(node, method) {
-    if (!node)
-      return;
+    if (!node) return;
     CompilerDOM.walkIdentifiers(node, (id) => {
       const binding = setupBindings[id.name];
       if (binding && binding !== "literal-const") {
@@ -20098,10 +20178,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(
-            `\`${imported}\` is a compiler macro and no longer needs to be imported.`
-          );
+        if (source2 === "vue" && MACROS.includes(imported)) {
+          if (local === imported) {
+            warnOnce(
+              `\`${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) {
@@ -20131,8 +20218,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) {
@@ -20246,6 +20332,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) {
@@ -20312,8 +20401,7 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
           }
         },
         exit(node2) {
-          if (node2.type === "BlockStatement")
-            scope.pop();
+          if (node2.type === "BlockStatement") scope.pop();
         }
       });
     }
@@ -20364,8 +20452,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) {
@@ -20536,12 +20623,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) {
@@ -20619,10 +20704,10 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
     );
     for (const { id, init: _init } of node.declarations) {
       const init = _init && CompilerDOM.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"];
@@ -20633,7 +20718,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) {
@@ -20654,9 +20739,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);
         }
       }
     }
@@ -20763,7 +20848,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.4.26";
+const version = "3.4.28";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,