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

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.0-alpha.2
+* @vue/compiler-sfc v3.5.0-alpha.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -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";
         }
       });
     }
@@ -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);
   }
@@ -13337,12 +13325,17 @@ function getHashDigest$1(buffer, algorithm, digestType, maxLength) {
     digestType === "base49" ||
     digestType === "base52" ||
     digestType === "base58" ||
-    digestType === "base62"
+    digestType === "base62" ||
+    digestType === "base64safe"
   ) {
-    return encodeBufferToBase(hash.digest(), digestType.substr(4), maxLength);
-  } else {
-    return hash.digest(digestType || "hex").substr(0, maxLength);
+    return encodeBufferToBase(
+      hash.digest(),
+      digestType === "base64safe" ? 64 : digestType.substr(4),
+      maxLength
+    );
   }
+
+  return hash.digest(digestType || "hex").substr(0, maxLength);
 }
 
 var getHashDigest_1 = getHashDigest$1;
@@ -13398,9 +13391,10 @@ function interpolateName$1(loaderContext, name, options = {}) {
       directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
     }
 
-    if (directory.length === 1) {
+    if (directory.length <= 1) {
       directory = "";
-    } else if (directory.length > 1) {
+    } else {
+      // directory.length > 1
       folder = path$2.basename(directory);
     }
   }
@@ -13423,7 +13417,7 @@ function interpolateName$1(loaderContext, name, options = {}) {
       // `hash` and `contenthash` are same in `loader-utils` context
       // let's keep `hash` for backward compatibility
       .replace(
-        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi,
+        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi,
         (all, hashType, digestType, maxLength) =>
           getHashDigest(content, hashType, digestType, parseInt(maxLength, 10))
       );
@@ -15604,11 +15598,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;
 }
@@ -15722,12 +15714,12 @@ function resolveParserPlugins(lang, userPlugins, dts = false) {
   )) {
     plugins.push("importAttributes");
   }
-  if (lang === "jsx" || lang === "tsx") {
+  if (lang === "jsx" || lang === "tsx" || lang === "mtsx") {
     plugins.push("jsx");
   } else if (userPlugins) {
     userPlugins = userPlugins.filter((p) => p !== "jsx");
   }
-  if (lang === "ts" || lang === "tsx") {
+  if (lang === "ts" || lang === "mts" || lang === "tsx" || lang === "mtsx") {
     plugins.push(["typescript", { dts }], "explicitResourceManagement");
     if (!userPlugins || !userPlugins.includes("decorators")) {
       plugins.push("decorators-legacy");
@@ -17441,10 +17433,11 @@ class Minimatch {
         for (let i = 0; i < globParts.length - 1; i++) {
             for (let j = i + 1; j < globParts.length; j++) {
                 const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-                if (!matched)
-                    continue;
-                globParts[i] = matched;
-                globParts[j] = [];
+                if (matched) {
+                    globParts[i] = [];
+                    globParts[j] = matched;
+                    break;
+                }
             }
         }
         return globParts.filter(gs => gs.length);
@@ -17945,12 +17938,16 @@ function resolveTypeElements(ctx, node, scope, typeParameters) {
 }
 function innerResolveTypeElements(ctx, node, scope, typeParameters) {
   var _a, _b;
+  if (node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
+    return { props: {} };
+  }
   switch (node.type) {
     case "TSTypeLiteral":
       return typeElementsToMap(ctx, node.members, scope, typeParameters);
     case "TSInterfaceDeclaration":
       return resolveInterfaceMembers(ctx, node, scope, typeParameters);
     case "TSTypeAliasDeclaration":
+    case "TSTypeAnnotation":
     case "TSParenthesizedType":
       return resolveTypeElements(
         ctx,
@@ -17968,7 +17965,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(
@@ -17997,8 +17994,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;
           });
         }
@@ -18108,8 +18104,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) {
@@ -18157,9 +18152,6 @@ function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
   );
   if (node.extends) {
     for (const ext of node.extends) {
-      if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
-        continue;
-      }
       try {
         const { props, calls } = resolveTypeElements(ctx, ext, scope);
         for (const key in props) {
@@ -18179,16 +18171,25 @@ If this previously worked in 3.2, you can instruct the compiler to ignore this e
 interface Props extends /* @vue-ignore */ Base {}
 
 Note: both in 3.2 or with the ignore, the properties in the base type are treated as fallthrough attrs at runtime.`,
-          ext
+          ext,
+          scope
         );
       }
     }
   }
   return base;
 }
-function resolveMappedType(ctx, node, scope) {
+function resolveMappedType(ctx, node, scope, typeParameters) {
   const res = { props: {} };
-  const keys = resolveStringType(ctx, node.typeParameter.constraint, scope);
+  let keys;
+  if (node.nameType) {
+    const { name, constraint } = node.typeParameter;
+    scope = createChildScope(scope);
+    Object.assign(scope.types, { ...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(
       {
@@ -18533,13 +18534,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.`,
@@ -18568,8 +18568,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`));
 }
@@ -18600,7 +18599,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;
           }
@@ -18648,8 +18647,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;
@@ -18660,8 +18663,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);
@@ -18678,12 +18680,12 @@ function fileToScope(ctx, filename, asGlobal = false) {
 }
 function parseFile(filename, content, parserPlugins) {
   const ext = path$3.extname(filename);
-  if (ext === ".ts" || ext === ".tsx") {
+  if (ext === ".ts" || ext === ".mts" || ext === ".tsx" || ext === ".mtsx") {
     return parser$1.parse(content, {
       plugins: resolveParserPlugins(
         ext.slice(1),
         parserPlugins,
-        filename.endsWith(".d.ts")
+        /\.d\.m?ts$/.test(filename)
       ),
       sourceType: "module"
     }).program.body;
@@ -18824,8 +18826,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;
@@ -18866,15 +18867,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) {
@@ -18938,7 +18937,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":
@@ -18956,13 +18955,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) {
@@ -18994,70 +19010,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;
@@ -19065,9 +19132,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
         );
       }
@@ -19099,27 +19166,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))
       )
     )
   ];
@@ -19175,8 +19253,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);
@@ -19216,8 +19293,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;
   }
@@ -19228,8 +19304,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") {
@@ -19306,8 +19381,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(
@@ -19509,8 +19583,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;
       }
     );
@@ -19680,8 +19753,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);
@@ -19907,8 +19979,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;
@@ -19918,14 +19989,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;
+        }
       }
     }
   }
@@ -19982,6 +20059,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) {
@@ -20049,8 +20135,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") {
@@ -20100,10 +20185,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) {
@@ -20133,8 +20225,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) {
@@ -20248,6 +20339,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) {
@@ -20283,7 +20377,8 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
         node,
         setupBindings,
         vueImportAliases,
-        hoistStatic
+        hoistStatic,
+        !!ctx.propsDestructureDecl
       );
     }
     if (hoistStatic && isAllLiteral) {
@@ -20314,8 +20409,7 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
           }
         },
         exit(node2) {
-          if (node2.type === "BlockStatement")
-            scope.pop();
+          if (node2.type === "BlockStatement") scope.pop();
         }
       });
     }
@@ -20366,8 +20460,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) {
@@ -20538,12 +20631,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) {
@@ -20612,7 +20703,7 @@ ${exposeCall}`
 function registerBinding(bindings, node, type) {
   bindings[node.name] = type;
 }
-function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
+function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic, isPropsDestructureEnabled = false) {
   let isAllLiteral = false;
   if (node.type === "VariableDeclaration") {
     const isConst = node.kind === "const";
@@ -20621,10 +20712,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"];
@@ -20635,7 +20726,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) {
@@ -20652,13 +20743,13 @@ function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
         }
         registerBinding(bindings, id, bindingType);
       } else {
-        if (isCallOf(init, DEFINE_PROPS)) {
+        if (isCallOf(init, DEFINE_PROPS) && isPropsDestructureEnabled) {
           continue;
         }
         if (id.type === "ObjectPattern") {
-          walkObjectPattern(id, bindings, isConst, isDefineCall);
+          walkObjectPattern(id, bindings, isConst, isConstMacroCall);
         } else if (id.type === "ArrayPattern") {
-          walkArrayPattern(id, bindings, isConst, isDefineCall);
+          walkArrayPattern(id, bindings, isConst, isConstMacroCall);
         }
       }
     }
@@ -20765,7 +20856,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.5.0-alpha.2";
+const version = "3.5.0-alpha.3";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,