@vue/compiler-sfc 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/compiler-sfc.cjs.js

@@ -226,7 +226,7 @@ function genCssVarsCode(vars, bindings, id, isProd) {
   }).join("");
   return `_${CSS_VARS_HELPER}(_ctx => (${transformedString}))`;
 }
-function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd) {
+function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd, defaultVar) {
   return `
 import { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'
 const __injectCSSVars__ = () => {
@@ -236,8 +236,8 @@ ${genCssVarsCode(
     id,
     isProd
   )}}
-const __setup__ = __default__.setup
-__default__.setup = __setup__
+const __setup__ = ${defaultVar}.setup
+${defaultVar}.setup = __setup__
   ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
   : __injectCSSVars__
 `;
@@ -3292,118 +3292,252 @@ function patchErrors(errors, source, inMap) {
   });
 }
 
-const defaultExportRE = /((?:^|\n|;)\s*)export(\s*)default/;
-const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)(?:as)?(\s*)default/s;
-const exportDefaultClassRE = /((?:^|\n|;)\s*)export\s+default\s+class\s+([\w$]+)/;
 function rewriteDefault(input, as, parserPlugins) {
-  if (!hasDefaultExport(input)) {
-    return input + `
-const ${as} = {}`;
-  }
-  let replaced;
-  const classMatch = input.match(exportDefaultClassRE);
-  if (classMatch) {
-    replaced = input.replace(exportDefaultClassRE, "$1class $2") + `
-const ${as} = ${classMatch[2]}`;
-  } else {
-    replaced = input.replace(defaultExportRE, `$1const ${as} =`);
-  }
-  if (!hasDefaultExport(replaced)) {
-    return replaced;
-  }
-  const s = new MagicString(input);
   const ast = parser$2.parse(input, {
     sourceType: "module",
     plugins: parserPlugins
   }).program.body;
+  const s = new MagicString(input);
+  rewriteDefaultAST(ast, s, as);
+  return s.toString();
+}
+function rewriteDefaultAST(ast, s, as) {
+  if (!hasDefaultExport(ast)) {
+    s.append(`
+const ${as} = {}`);
+    return;
+  }
   ast.forEach((node) => {
     if (node.type === "ExportDefaultDeclaration") {
       if (node.declaration.type === "ClassDeclaration") {
-        s.overwrite(node.start, node.declaration.id.start, `class `);
+        let start = node.declaration.decorators && node.declaration.decorators.length > 0 ? node.declaration.decorators[node.declaration.decorators.length - 1].end : node.start;
+        s.overwrite(start, node.declaration.id.start, ` class `);
         s.append(`
 const ${as} = ${node.declaration.id.name}`);
       } else {
         s.overwrite(node.start, node.declaration.start, `const ${as} = `);
       }
-    }
-    if (node.type === "ExportNamedDeclaration") {
+    } else if (node.type === "ExportNamedDeclaration") {
       for (const specifier of node.specifiers) {
         if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.exported.name === "default") {
           if (node.source) {
             if (specifier.local.name === "default") {
-              const end2 = specifierEnd(input, specifier.local.end, node.end);
               s.prepend(
                 `import { default as __VUE_DEFAULT__ } from '${node.source.value}'
 `
               );
-              s.overwrite(specifier.start, end2, ``);
+              const end2 = specifierEnd(s, specifier.local.end, node.end);
+              s.remove(specifier.start, end2);
               s.append(`
 const ${as} = __VUE_DEFAULT__`);
               continue;
             } else {
-              const end2 = specifierEnd(
-                input,
-                specifier.exported.end,
-                node.end
-              );
               s.prepend(
-                `import { ${input.slice(
+                `import { ${s.slice(
                   specifier.local.start,
                   specifier.local.end
-                )} } from '${node.source.value}'
+                )} as __VUE_DEFAULT__ } from '${node.source.value}'
 `
               );
-              s.overwrite(specifier.start, end2, ``);
+              const end2 = specifierEnd(s, specifier.exported.end, node.end);
+              s.remove(specifier.start, end2);
               s.append(`
-const ${as} = ${specifier.local.name}`);
+const ${as} = __VUE_DEFAULT__`);
               continue;
             }
           }
-          const end = specifierEnd(input, specifier.end, node.end);
-          s.overwrite(specifier.start, end, ``);
+          const end = specifierEnd(s, specifier.end, node.end);
+          s.remove(specifier.start, end);
           s.append(`
 const ${as} = ${specifier.local.name}`);
         }
       }
     }
   });
-  return s.toString();
 }
-function hasDefaultExport(input) {
-  return defaultExportRE.test(input) || namedDefaultExportRE.test(input);
+function hasDefaultExport(ast) {
+  for (const stmt of ast) {
+    if (stmt.type === "ExportDefaultDeclaration") {
+      return true;
+    } else if (stmt.type === "ExportNamedDeclaration" && stmt.specifiers.some(
+      (spec) => spec.exported.name === "default"
+    )) {
+      return true;
+    }
+  }
+  return false;
 }
-function specifierEnd(input, end, nodeEnd) {
+function specifierEnd(s, end, nodeEnd) {
   let hasCommas = false;
   let oldEnd = end;
   while (end < nodeEnd) {
-    if (/\s/.test(input.charAt(end))) {
+    if (/\s/.test(s.slice(end, end + 1))) {
       end++;
-    } else if (input.charAt(end) === ",") {
+    } else if (s.slice(end, end + 1) === ",") {
       end++;
       hasCommas = true;
       break;
-    } else if (input.charAt(end) === "}") {
+    } else if (s.slice(end, end + 1) === "}") {
       break;
     }
   }
   return hasCommas ? end : oldEnd;
 }
 
+function transformDestructuredProps(ast, s, offset = 0, knownProps, error, watchMethodName = "watch") {
+  const rootScope = {};
+  const scopeStack = [rootScope];
+  let currentScope = rootScope;
+  const excludedIds = /* @__PURE__ */ new WeakSet();
+  const parentStack = [];
+  const propsLocalToPublicMap = /* @__PURE__ */ Object.create(null);
+  for (const key in knownProps) {
+    const { local } = knownProps[key];
+    rootScope[local] = true;
+    propsLocalToPublicMap[local] = key;
+  }
+  function registerLocalBinding(id) {
+    excludedIds.add(id);
+    if (currentScope) {
+      currentScope[id.name] = false;
+    } else {
+      error(
+        "registerBinding called without active scope, something is wrong.",
+        id
+      );
+    }
+  }
+  function walkScope(node, isRoot = false) {
+    for (const stmt of node.body) {
+      if (stmt.type === "VariableDeclaration") {
+        walkVariableDeclaration(stmt, isRoot);
+      } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+        if (stmt.declare || !stmt.id)
+          continue;
+        registerLocalBinding(stmt.id);
+      } else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
+        walkVariableDeclaration(stmt.left);
+      } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") {
+        walkVariableDeclaration(stmt.declaration, isRoot);
+      } else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") {
+        walkVariableDeclaration(stmt.body, isRoot);
+      }
+    }
+  }
+  function walkVariableDeclaration(stmt, isRoot = false) {
+    if (stmt.declare) {
+      return;
+    }
+    for (const decl of stmt.declarations) {
+      const isDefineProps = isRoot && decl.init && compilerCore.isCallOf(compilerCore.unwrapTSNode(decl.init), "defineProps");
+      for (const id of compilerCore.extractIdentifiers(decl.id)) {
+        if (isDefineProps) {
+          excludedIds.add(id);
+        } else {
+          registerLocalBinding(id);
+        }
+      }
+    }
+  }
+  function rewriteId(scope, id, parent, parentStack2) {
+    if (shared.hasOwn(scope, id.name)) {
+      const binding = scope[id.name];
+      if (binding) {
+        if (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression") {
+          error(`Cannot assign to destructured props as they are readonly.`, id);
+        }
+        if (compilerCore.isStaticProperty(parent) && parent.shorthand) {
+          if (!parent.inPattern || compilerCore.isInDestructureAssignment(parent, parentStack2)) {
+            s.appendLeft(
+              id.end + offset,
+              `: ${shared.genPropsAccessExp(propsLocalToPublicMap[id.name])}`
+            );
+          }
+        } else {
+          s.overwrite(
+            id.start + offset,
+            id.end + offset,
+            shared.genPropsAccessExp(propsLocalToPublicMap[id.name])
+          );
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  walkScope(ast, true);
+  estreeWalker.walk(ast, {
+    enter(node, parent) {
+      parent && parentStack.push(parent);
+      if (parent && parent.type.startsWith("TS") && parent.type !== "TSAsExpression" && parent.type !== "TSNonNullExpression" && parent.type !== "TSTypeAssertion") {
+        return this.skip();
+      }
+      if (compilerCore.isCallOf(node, watchMethodName)) {
+        const arg = compilerCore.unwrapTSNode(node.arguments[0]);
+        if (arg.type === "Identifier") {
+          error(
+            `"${arg.name}" is a destructured prop and cannot be directly watched. Use a getter () => ${arg.name} instead.`,
+            arg
+          );
+        }
+      }
+      if (compilerCore.isFunctionType(node)) {
+        scopeStack.push(currentScope = {});
+        compilerCore.walkFunctionParams(node, registerLocalBinding);
+        if (node.body.type === "BlockStatement") {
+          walkScope(node.body);
+        }
+        return;
+      }
+      if (node.type === "CatchClause") {
+        scopeStack.push(currentScope = {});
+        if (node.param && node.param.type === "Identifier") {
+          registerLocalBinding(node.param);
+        }
+        walkScope(node.body);
+        return;
+      }
+      if (node.type === "BlockStatement" && !compilerCore.isFunctionType(parent)) {
+        scopeStack.push(currentScope = {});
+        walkScope(node);
+        return;
+      }
+      if (node.type === "Identifier") {
+        if (compilerCore.isReferencedIdentifier(node, parent, parentStack) && !excludedIds.has(node)) {
+          let i = scopeStack.length;
+          while (i--) {
+            if (rewriteId(scopeStack[i], node, parent, parentStack)) {
+              return;
+            }
+          }
+        }
+      }
+    },
+    leave(node, parent) {
+      parent && parentStack.pop();
+      if (node.type === "BlockStatement" && !compilerCore.isFunctionType(parent) || compilerCore.isFunctionType(node)) {
+        scopeStack.pop();
+        currentScope = scopeStack[scopeStack.length - 1] || null;
+      }
+    }
+  });
+}
+
 const DEFINE_PROPS = "defineProps";
 const DEFINE_EMITS = "defineEmits";
 const DEFINE_EXPOSE = "defineExpose";
 const WITH_DEFAULTS = "withDefaults";
-const DEFAULT_VAR = `__default__`;
+const DEFINE_OPTIONS = "defineOptions";
 const isBuiltInDir = shared.makeMap(
   `once,memo,if,for,else,else-if,slot,text,html,on,bind,model,show,cloak,is`
 );
 function compileScript(sfc, options) {
   var _a;
   let { script, scriptSetup, source, filename } = sfc;
-  const enableReactivityTransform = !!options.reactivityTransform || !!options.refSugar || !!options.refTransform;
-  const enablePropsTransform = !!options.reactivityTransform || !!options.propsDestructureTransform;
+  const enableReactivityTransform = !!options.reactivityTransform;
   const isProd = !!options.isProd;
   const genSourceMap = options.sourceMap !== false;
+  const hoistStatic = options.hoistStatic !== false && !script;
   let refBindings;
   if (!options.id) {
     warnOnce(
@@ -3415,6 +3549,9 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
   const cssVars = sfc.cssVars;
   const scriptLang = script && script.lang;
   const scriptSetupLang = scriptSetup && scriptSetup.lang;
+  const genDefaultAs = options.genDefaultAs ? `const ${options.genDefaultAs} =` : `export default`;
+  const normalScriptDefaultVar = `__default__`;
+  const isJS = scriptLang === "js" || scriptLang === "jsx" || scriptSetupLang === "js" || scriptSetupLang === "jsx";
   const isTS = scriptLang === "ts" || scriptLang === "tsx" || scriptSetupLang === "ts" || scriptSetupLang === "tsx";
   const plugins = [];
   if (!isTS || scriptLang === "tsx" || scriptSetupLang === "tsx") {
@@ -3437,7 +3574,7 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
     if (!script) {
       throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`);
     }
-    if (scriptLang && !isTS && scriptLang !== "jsx") {
+    if (scriptLang && !isJS && !isTS) {
       return script;
     }
     try {
@@ -3470,16 +3607,24 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
           });
         }
       }
-      if (cssVars.length) {
-        content = rewriteDefault(content, DEFAULT_VAR, plugins);
-        content += genNormalScriptCssVarsCode(
-          cssVars,
-          bindings,
-          scopeId,
-          isProd
-        );
-        content += `
-export default ${DEFAULT_VAR}`;
+      if (cssVars.length || options.genDefaultAs) {
+        const defaultVar = options.genDefaultAs || normalScriptDefaultVar;
+        const s2 = new MagicString(content);
+        rewriteDefaultAST(scriptAst2.body, s2, defaultVar);
+        content = s2.toString();
+        if (cssVars.length) {
+          content += genNormalScriptCssVarsCode(
+            cssVars,
+            bindings,
+            scopeId,
+            isProd,
+            defaultVar
+          );
+        }
+        if (!options.genDefaultAs) {
+          content += `
+export default ${defaultVar}`;
+        }
       }
       return {
         ...script,
@@ -3497,7 +3642,7 @@ export default ${DEFAULT_VAR}`;
       `[@vue/compiler-sfc] <script> and <script setup> must have the same language type.`
     );
   }
-  if (scriptSetupLang && !isTS && scriptSetupLang !== "jsx") {
+  if (scriptSetupLang && !isJS && !isTS) {
     return scriptSetup;
   }
   const bindingMetadata = {};
@@ -3511,6 +3656,7 @@ export default ${DEFAULT_VAR}`;
   let hasDefineExposeCall = false;
   let hasDefaultExportName = false;
   let hasDefaultExportRender = false;
+  let hasDefineOptionsCall = false;
   let propsRuntimeDecl;
   let propsRuntimeDefaults;
   let propsDestructureDecl;
@@ -3522,6 +3668,7 @@ export default ${DEFAULT_VAR}`;
   let emitsTypeDecl;
   let emitsTypeDeclRaw;
   let emitIdentifier;
+  let optionsRuntimeDecl;
   let hasAwait = false;
   let hasInlinedSsrRenderFn = false;
   const typeDeclaredProps = {};
@@ -3582,15 +3729,15 @@ ${shared.generateCodeFrame(
     }
     userImports[local] = {
       isType,
-      imported: imported || "default",
+      imported,
       local,
       source: source2,
       isFromSetup,
       isUsedInTemplate
     };
   }
-  function processDefineProps(node, declId, declKind) {
-    if (!isCallOf(node, DEFINE_PROPS)) {
+  function processDefineProps(node, declId) {
+    if (!CompilerDOM.isCallOf(node, DEFINE_PROPS)) {
       return false;
     }
     if (hasDefinePropsCall) {
@@ -3618,8 +3765,7 @@ ${shared.generateCodeFrame(
       }
     }
     if (declId) {
-      const isConst = declKind === "const";
-      if (enablePropsTransform && declId.type === "ObjectPattern") {
+      if (declId.type === "ObjectPattern") {
         propsDestructureDecl = declId;
         for (const prop of declId.properties) {
           if (prop.type === "ObjectProperty") {
@@ -3640,13 +3786,11 @@ ${shared.generateCodeFrame(
               }
               propsDestructuredBindings[propKey] = {
                 local: left.name,
-                default: right,
-                isConst
+                default: right
               };
             } else if (prop.value.type === "Identifier") {
               propsDestructuredBindings[propKey] = {
-                local: prop.value.name,
-                isConst
+                local: prop.value.name
               };
             } else {
               error(
@@ -3665,10 +3809,13 @@ ${shared.generateCodeFrame(
     return true;
   }
   function processWithDefaults(node, declId, declKind) {
-    if (!isCallOf(node, WITH_DEFAULTS)) {
+    if (!CompilerDOM.isCallOf(node, WITH_DEFAULTS)) {
       return false;
     }
-    if (processDefineProps(node.arguments[0], declId, declKind)) {
+    warnOnce(
+      `withDefaults() has been deprecated. Props destructure is now reactive by default - use destructure with default values instead.`
+    );
+    if (processDefineProps(node.arguments[0], declId)) {
       if (propsRuntimeDecl) {
         error(
           `${WITH_DEFAULTS} can only be used with type-based ${DEFINE_PROPS} declaration.`,
@@ -3698,7 +3845,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     return true;
   }
   function processDefineEmits(node, declId) {
-    if (!isCallOf(node, DEFINE_EMITS)) {
+    if (!CompilerDOM.isCallOf(node, DEFINE_EMITS)) {
       return false;
     }
     if (hasDefineEmitCall) {
@@ -3779,6 +3926,53 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
       });
     });
   }
+  function processDefineOptions(node) {
+    if (!CompilerDOM.isCallOf(node, DEFINE_OPTIONS)) {
+      return false;
+    }
+    if (hasDefineOptionsCall) {
+      error(`duplicate ${DEFINE_OPTIONS}() call`, node);
+    }
+    if (node.typeParameters) {
+      error(`${DEFINE_OPTIONS}() cannot accept type arguments`, node);
+    }
+    hasDefineOptionsCall = true;
+    optionsRuntimeDecl = node.arguments[0];
+    let propsOption = void 0;
+    let emitsOption = void 0;
+    let exposeOption = void 0;
+    if (optionsRuntimeDecl.type === "ObjectExpression") {
+      for (const prop of 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 (propsOption) {
+      error(
+        `${DEFINE_OPTIONS}() cannot be used to declare props. Use ${DEFINE_PROPS}() instead.`,
+        propsOption
+      );
+    }
+    if (emitsOption) {
+      error(
+        `${DEFINE_OPTIONS}() cannot be used to declare emits. Use ${DEFINE_EMITS}() instead.`,
+        emitsOption
+      );
+    }
+    if (exposeOption) {
+      error(
+        `${DEFINE_OPTIONS}() cannot be used to declare expose. Use ${DEFINE_EXPOSE}() instead.`,
+        exposeOption
+      );
+    }
+    return true;
+  }
   function resolveQualifiedType(node, qualifier) {
     if (qualifier(node)) {
       return node;
@@ -3807,7 +4001,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     }
   }
   function processDefineExpose(node) {
-    if (isCallOf(node, DEFINE_EXPOSE)) {
+    if (CompilerDOM.isCallOf(node, DEFINE_EXPOSE)) {
       if (hasDefineExposeCall) {
         error(`duplicate ${DEFINE_EXPOSE}() call`, node);
       }
@@ -3820,7 +4014,8 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     if (!node)
       return;
     CompilerDOM.walkIdentifiers(node, (id) => {
-      if (setupBindings[id.name]) {
+      const binding = setupBindings[id.name];
+      if (binding && (binding !== "literal-const" || !hoistStatic)) {
         error(
           `\`${method}()\` in <script setup> cannot reference locally declared variables because it will be hoisted outside of the setup() function. If your component options require initialization in the module scope, use a separate normal <script> to export the options instead.`,
           id
@@ -3867,9 +4062,9 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     let propsDecls = `{
     ${keys.map((key) => {
       let defaultString;
-      const destructured = genDestructuredDefaultValue(key);
+      const destructured = genDestructuredDefaultValue(key, props[key].type);
       if (destructured) {
-        defaultString = `default: ${destructured}`;
+        defaultString = `default: ${destructured.valueString}${destructured.needSkipFactory ? `, skipFactory: true` : ``}`;
       } else if (hasStaticDefaults) {
         const prop = propsRuntimeDefaults.properties.find((node) => {
           if (node.type === "SpreadElement")
@@ -3890,11 +4085,11 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
           }
         }
       }
-      const { type, required } = props[key];
+      const { type, required, skipCheck } = props[key];
       if (!isProd) {
         return `${key}: { type: ${toRuntimeTypeString(
           type
-        )}, required: ${required}${defaultString ? `, ${defaultString}` : ``} }`;
+        )}, required: ${required}${skipCheck ? ", skipCheck: true" : ""}${defaultString ? `, ${defaultString}` : ``} }`;
       } else if (type.some(
         (el) => el === "Boolean" || (!hasStaticDefaults || defaultString) && el === "Function"
       )) {
@@ -3913,15 +4108,30 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     return `
   props: ${propsDecls},`;
   }
-  function genDestructuredDefaultValue(key) {
+  function genDestructuredDefaultValue(key, inferredType) {
     const destructured = propsDestructuredBindings[key];
-    if (destructured && destructured.default) {
+    const defaultVal = destructured && destructured.default;
+    if (defaultVal) {
       const value = scriptSetup.content.slice(
-        destructured.default.start,
-        destructured.default.end
+        defaultVal.start,
+        defaultVal.end
       );
-      const isLiteral = destructured.default.type.endsWith("Literal");
-      return isLiteral ? value : `() => (${value})`;
+      const unwrapped = CompilerDOM.unwrapTSNode(defaultVal);
+      if (inferredType && inferredType.length && !inferredType.includes(UNKNOWN_TYPE)) {
+        const valueType = inferValueType(unwrapped);
+        if (valueType && !inferredType.includes(valueType)) {
+          error(
+            `Default value of prop "${key}" does not match declared type.`,
+            unwrapped
+          );
+        }
+      }
+      const needSkipFactory = !inferredType && (CompilerDOM.isFunctionType(unwrapped) || unwrapped.type === "Identifier");
+      const needFactoryWrap = !needSkipFactory && !isLiteralNode(unwrapped) && !(inferredType == null ? void 0 : inferredType.includes("Function"));
+      return {
+        valueString: needFactoryWrap ? `() => (${value})` : value,
+        needSkipFactory
+      };
     }
   }
   function genSetupPropsType(node) {
@@ -3974,7 +4184,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
     for (const node of scriptAst.body) {
       if (node.type === "ImportDeclaration") {
         for (const specifier of node.specifiers) {
-          const imported = specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name;
+          const imported = CompilerDOM.getImportedName(specifier);
           registerUserImport(
             node.source.value,
             specifier.local.name,
@@ -4004,10 +4214,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
       for (let i = 0; i < node.specifiers.length; i++) {
         const specifier = node.specifiers[i];
         const local = specifier.local.name;
-        let imported = specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name;
-        if (specifier.type === "ImportNamespaceSpecifier") {
-          imported = "*";
-        }
+        const imported = CompilerDOM.getImportedName(specifier);
         const source2 = node.source.value;
         const existing = userImports[local];
         if (source2 === "vue" && (imported === DEFINE_PROPS || imported === DEFINE_EMITS || imported === DEFINE_EXPOSE)) {
@@ -4050,7 +4257,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
         let optionProperties;
         if (defaultExport.declaration.type === "ObjectExpression") {
           optionProperties = defaultExport.declaration.properties;
-        } else if (defaultExport.declaration.type === "CallExpression" && defaultExport.declaration.arguments[0].type === "ObjectExpression") {
+        } else if (defaultExport.declaration.type === "CallExpression" && defaultExport.declaration.arguments[0] && defaultExport.declaration.arguments[0].type === "ObjectExpression") {
           optionProperties = defaultExport.declaration.arguments[0].properties;
         }
         if (optionProperties) {
@@ -4065,7 +4272,7 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
         }
         const start = node.start + scriptStartOffset;
         const end = node.declaration.start + scriptStartOffset;
-        s.overwrite(start, end, `const ${DEFAULT_VAR} = `);
+        s.overwrite(start, end, `const ${normalScriptDefaultVar} = `);
       } else if (node.type === "ExportNamedDeclaration") {
         const defaultSpecifier = node.specifiers.find(
           (s2) => s2.exported.type === "Identifier" && s2.exported.name === "default"
@@ -4085,14 +4292,14 @@ Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(..
           }
           if (node.source) {
             s.prepend(
-              `import { ${defaultSpecifier.local.name} as ${DEFAULT_VAR} } from '${node.source.value}'
+              `import { ${defaultSpecifier.local.name} as ${normalScriptDefaultVar} } from '${node.source.value}'
 `
             );
           } else {
             s.appendLeft(
               scriptEndOffset,
               `
-const ${DEFAULT_VAR} = ${defaultSpecifier.local.name}
+const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
 `
             );
           }
@@ -4131,45 +4338,60 @@ const ${DEFAULT_VAR} = ${defaultSpecifier.local.name}
       );
     }
     if (node.type === "ExpressionStatement") {
-      if (processDefineProps(node.expression) || processDefineEmits(node.expression) || processWithDefaults(node.expression)) {
+      const expr = CompilerDOM.unwrapTSNode(node.expression);
+      if (processDefineProps(expr) || processDefineEmits(expr) || processDefineOptions(expr) || processWithDefaults(expr)) {
         s.remove(node.start + startOffset, node.end + startOffset);
-      } else if (processDefineExpose(node.expression)) {
-        const callee = node.expression.callee;
+      } else if (processDefineExpose(expr)) {
+        const callee = expr.callee;
         s.overwrite(
           callee.start + startOffset,
           callee.end + startOffset,
-          "expose"
+          "__expose"
         );
       }
     }
     if (node.type === "VariableDeclaration" && !node.declare) {
       const total = node.declarations.length;
       let left = total;
+      let lastNonRemoved;
       for (let i = 0; i < total; i++) {
         const decl = node.declarations[i];
-        if (decl.init) {
-          const isDefineProps = processDefineProps(decl.init, decl.id, node.kind) || processWithDefaults(decl.init, decl.id, node.kind);
-          const isDefineEmits = processDefineEmits(decl.init, decl.id);
+        const init = decl.init && CompilerDOM.unwrapTSNode(decl.init);
+        if (init) {
+          if (processDefineOptions(init)) {
+            error(
+              `${DEFINE_OPTIONS}() has no returning value, it cannot be assigned.`,
+              node
+            );
+          }
+          const isDefineProps = processDefineProps(init, decl.id) || processWithDefaults(init, decl.id, node.kind);
+          const isDefineEmits = processDefineEmits(init, decl.id);
           if (isDefineProps || isDefineEmits) {
             if (left === 1) {
               s.remove(node.start + startOffset, node.end + startOffset);
             } else {
               let start = decl.start + startOffset;
               let end = decl.end + startOffset;
-              if (i === 0) {
-                end = node.declarations[i + 1].start + startOffset;
+              if (i === total - 1) {
+                start = node.declarations[lastNonRemoved].end + startOffset;
               } else {
-                start = node.declarations[i - 1].end + startOffset;
+                end = node.declarations[i + 1].start + startOffset;
               }
               s.remove(start, end);
               left--;
             }
+          } else {
+            lastNonRemoved = i;
           }
         }
       }
     }
-    if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && !node.declare) {
-      walkDeclaration(node, setupBindings, vueImportAliases);
+    let isAllLiteral = false;
+    if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") && !node.declare) {
+      isAllLiteral = walkDeclaration(node, setupBindings, vueImportAliases);
+    }
+    if (hoistStatic && isAllLiteral) {
+      hoistNode(node);
     }
     if (node.type === "VariableDeclaration" && !node.declare || node.type.endsWith("Statement")) {
       const scope = [scriptSetupAst.body];
@@ -4207,23 +4429,31 @@ const ${DEFAULT_VAR} = ${defaultSpecifier.local.name}
       );
     }
     if (isTS) {
-      if (node.type === "TSEnumDeclaration") {
-        registerBinding(setupBindings, node.id, "setup-const");
-      }
       if (node.type.startsWith("TS") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "VariableDeclaration" && node.declare) {
         recordType(node, declaredTypes);
-        hoistNode(node);
+        if (node.type !== "TSEnumDeclaration") {
+          hoistNode(node);
+        }
       }
     }
   }
+  if (propsDestructureDecl) {
+    transformDestructuredProps(
+      scriptSetupAst,
+      s,
+      startOffset,
+      propsDestructuredBindings,
+      error,
+      vueImportAliases.watch
+    );
+  }
   if (enableReactivityTransform && // normal <script> had ref bindings that maybe used in <script setup>
-  (refBindings || reactivityTransform.shouldTransform(scriptSetup.content)) || propsDestructureDecl) {
+  (refBindings || reactivityTransform.shouldTransform(scriptSetup.content))) {
     const { rootRefs, importedHelpers } = reactivityTransform.transformAST(
       scriptSetupAst,
       s,
       startOffset,
-      refBindings,
-      propsDestructuredBindings
+      refBindings
     );
     refBindings = refBindings ? [...refBindings, ...rootRefs] : rootRefs;
     for (const h of importedHelpers) {
@@ -4240,6 +4470,7 @@ const ${DEFAULT_VAR} = ${defaultSpecifier.local.name}
   checkInvalidScopeReference(propsRuntimeDefaults, DEFINE_PROPS);
   checkInvalidScopeReference(propsDestructureDecl, DEFINE_PROPS);
   checkInvalidScopeReference(emitsRuntimeDecl, DEFINE_EMITS);
+  checkInvalidScopeReference(optionsRuntimeDecl, DEFINE_OPTIONS);
   if (script) {
     if (startOffset < scriptStartOffset) {
       s.remove(0, startOffset);
@@ -4299,7 +4530,7 @@ const ${DEFAULT_VAR} = ${defaultSpecifier.local.name}
   !(options.inlineTemplate && ((_a = options.templateOptions) == null ? void 0 : _a.ssr))) {
     helperImports.add(CSS_VARS_HELPER);
     helperImports.add("unref");
-    s.prependRight(
+    s.prependLeft(
       startOffset,
       `
 ${genCssVarsCode(cssVars, bindingMetadata, scopeId, isProd)}
@@ -4334,7 +4565,7 @@ const ${propsDestructureRestId} = ${helper(
 let __temp${any}, __restore${any}
 `);
   }
-  const destructureElements = hasDefineExposeCall || !options.inlineTemplate ? [`expose`] : [];
+  const destructureElements = hasDefineExposeCall || !options.inlineTemplate ? [`expose: __expose`] : [];
   if (emitIdentifier) {
     destructureElements.push(
       emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`
@@ -4461,7 +4692,9 @@ return ${returned}
       for (const key in propsDestructuredBindings) {
         const d = genDestructuredDefaultValue(key);
         if (d)
-          defaults.push(`${key}: ${d}`);
+          defaults.push(
+            `${key}: ${d.valueString}${d.needSkipFactory ? `, __skip_${key}: true` : ``}`
+          );
       }
       if (defaults.length) {
         declCode = `${helper(
@@ -4482,15 +4715,20 @@ return ${returned}
   } else if (emitsTypeDecl) {
     runtimeOptions += genRuntimeEmits(typeDeclaredEmits);
   }
-  const exposeCall = hasDefineExposeCall || options.inlineTemplate ? `` : `  expose();
+  let definedOptions = "";
+  if (optionsRuntimeDecl) {
+    definedOptions = scriptSetup.content.slice(optionsRuntimeDecl.start, optionsRuntimeDecl.end).trim();
+  }
+  const exposeCall = hasDefineExposeCall || options.inlineTemplate ? `` : `  __expose();
 `;
   if (isTS) {
-    const def = defaultExport ? `
-  ...${DEFAULT_VAR},` : ``;
+    const def = (defaultExport ? `
+  ...${normalScriptDefaultVar},` : ``) + (definedOptions ? `
+  ...${definedOptions},` : "");
     s.prependLeft(
       startOffset,
       `
-export default /*#__PURE__*/${helper(
+${genDefaultAs} /*#__PURE__*/${helper(
         `defineComponent`
       )}({${def}${runtimeOptions}
   ${hasAwait ? `async ` : ``}setup(${args}) {
@@ -4498,11 +4736,11 @@ ${exposeCall}`
     );
     s.appendRight(endOffset, `})`);
   } else {
-    if (defaultExport) {
+    if (defaultExport || definedOptions) {
       s.prependLeft(
         startOffset,
         `
-export default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}
+${genDefaultAs} /*#__PURE__*/Object.assign(${defaultExport ? `${normalScriptDefaultVar}, ` : ""}${definedOptions ? `${definedOptions}, ` : ""}{${runtimeOptions}
   ${hasAwait ? `async ` : ``}setup(${args}) {
 ${exposeCall}`
       );
@@ -4511,7 +4749,7 @@ ${exposeCall}`
       s.prependLeft(
         startOffset,
         `
-export default {${runtimeOptions}
+${genDefaultAs} {${runtimeOptions}
   ${hasAwait ? `async ` : ``}setup(${args}) {
 ${exposeCall}`
       );
@@ -4543,26 +4781,33 @@ function registerBinding(bindings, node, type) {
   bindings[node.name] = type;
 }
 function walkDeclaration(node, bindings, userImportAliases) {
+  let isAllLiteral = false;
   if (node.type === "VariableDeclaration") {
     const isConst = node.kind === "const";
-    for (const { id, init } of node.declarations) {
-      const isDefineCall = !!(isConst && isCallOf(
+    isAllLiteral = isConst && node.declarations.every(
+      (decl) => decl.id.type === "Identifier" && isStaticNode(decl.init)
+    );
+    for (const { id, init: _init } of node.declarations) {
+      const init = _init && CompilerDOM.unwrapTSNode(_init);
+      const isDefineCall = !!(isConst && CompilerDOM.isCallOf(
         init,
         (c) => c === DEFINE_PROPS || c === DEFINE_EMITS || c === WITH_DEFAULTS
       ));
       if (id.type === "Identifier") {
         let bindingType;
         const userReactiveBinding = userImportAliases["reactive"];
-        if (isCallOf(init, userReactiveBinding)) {
+        if (isAllLiteral || isConst && isStaticNode(init)) {
+          bindingType = "literal-const";
+        } else if (CompilerDOM.isCallOf(init, userReactiveBinding)) {
           bindingType = isConst ? "setup-reactive-const" : "setup-let";
         } 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)
         ) {
-          bindingType = isCallOf(init, DEFINE_PROPS) ? "setup-reactive-const" : "setup-const";
+          bindingType = CompilerDOM.isCallOf(init, DEFINE_PROPS) ? "setup-reactive-const" : "setup-const";
         } else if (isConst) {
-          if (isCallOf(init, userImportAliases["ref"])) {
+          if (CompilerDOM.isCallOf(init, userImportAliases["ref"])) {
             bindingType = "setup-ref";
           } else {
             bindingType = "setup-maybe-ref";
@@ -4572,7 +4817,7 @@ function walkDeclaration(node, bindings, userImportAliases) {
         }
         registerBinding(bindings, id, bindingType);
       } else {
-        if (isCallOf(init, DEFINE_PROPS)) {
+        if (CompilerDOM.isCallOf(init, DEFINE_PROPS)) {
           continue;
         }
         if (id.type === "ObjectPattern") {
@@ -4582,9 +4827,15 @@ function walkDeclaration(node, bindings, userImportAliases) {
         }
       }
     }
-  } else if (node.type === "TSEnumDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+  } else if (node.type === "TSEnumDeclaration") {
+    isAllLiteral = node.members.every(
+      (member) => !member.initializer || isStaticNode(member.initializer)
+    );
+    bindings[node.id.name] = isAllLiteral ? "literal-const" : "setup-const";
+  } else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
     bindings[node.id.name] = "setup-const";
   }
+  return isAllLiteral;
 }
 function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
   for (const p of node.properties) {
@@ -4636,26 +4887,39 @@ function recordType(node, declaredTypes) {
     );
   } else if (node.type === "ExportNamedDeclaration" && node.declaration) {
     recordType(node.declaration, declaredTypes);
+  } else if (node.type === "TSEnumDeclaration") {
+    declaredTypes[node.id.name] = inferEnumType(node);
   }
 }
-function extractRuntimeProps(node, props, declaredTypes, isProd) {
+function extractRuntimeProps(node, props, declaredTypes) {
   const members = node.type === "TSTypeLiteral" ? node.members : node.body;
   for (const m of members) {
     if ((m.type === "TSPropertySignature" || m.type === "TSMethodSignature") && m.key.type === "Identifier") {
       let type;
+      let skipCheck = false;
       if (m.type === "TSMethodSignature") {
         type = ["Function"];
       } else if (m.typeAnnotation) {
         type = inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes);
+        if (type.includes(UNKNOWN_TYPE)) {
+          if (type.includes("Boolean") || type.includes("Function")) {
+            type = type.filter((t) => t !== UNKNOWN_TYPE);
+            skipCheck = true;
+          } else {
+            type = ["null"];
+          }
+        }
       }
       props[m.key.name] = {
         key: m.key.name,
         required: !m.optional,
-        type: type || [`null`]
+        type: type || [`null`],
+        skipCheck
       };
     }
   }
 }
+const UNKNOWN_TYPE = "Unknown";
 function inferRuntimeType(node, declaredTypes) {
   switch (node.type) {
     case "TSStringKeyword":
@@ -4666,8 +4930,19 @@ function inferRuntimeType(node, declaredTypes) {
       return ["Boolean"];
     case "TSObjectKeyword":
       return ["Object"];
-    case "TSTypeLiteral":
-      return ["Object"];
+    case "TSNullKeyword":
+      return ["null"];
+    case "TSTypeLiteral": {
+      const types = /* @__PURE__ */ new Set();
+      for (const m of node.members) {
+        if (m.type === "TSCallSignatureDeclaration" || m.type === "TSConstructSignatureDeclaration") {
+          types.add("Function");
+        } else {
+          types.add("Object");
+        }
+      }
+      return types.size ? Array.from(types) : ["Object"];
+    }
     case "TSFunctionType":
       return ["Function"];
     case "TSArrayType":
@@ -4683,7 +4958,7 @@ function inferRuntimeType(node, declaredTypes) {
         case "BigIntLiteral":
           return ["Number"];
         default:
-          return [`null`];
+          return [UNKNOWN_TYPE];
       }
     case "TSTypeReference":
       if (node.typeName.type === "Identifier") {
@@ -4701,40 +4976,110 @@ function inferRuntimeType(node, declaredTypes) {
           case "Date":
           case "Promise":
             return [node.typeName.name];
-          case "Record":
           case "Partial":
+          case "Required":
           case "Readonly":
+          case "Record":
           case "Pick":
           case "Omit":
-          case "Exclude":
-          case "Extract":
-          case "Required":
           case "InstanceType":
             return ["Object"];
+          case "Uppercase":
+          case "Lowercase":
+          case "Capitalize":
+          case "Uncapitalize":
+            return ["String"];
+          case "Parameters":
+          case "ConstructorParameters":
+            return ["Array"];
+          case "NonNullable":
+            if (node.typeParameters && node.typeParameters.params[0]) {
+              return inferRuntimeType(
+                node.typeParameters.params[0],
+                declaredTypes
+              ).filter((t) => t !== "null");
+            }
+            break;
+          case "Extract":
+            if (node.typeParameters && node.typeParameters.params[1]) {
+              return inferRuntimeType(
+                node.typeParameters.params[1],
+                declaredTypes
+              );
+            }
+            break;
+          case "Exclude":
+          case "OmitThisParameter":
+            if (node.typeParameters && node.typeParameters.params[0]) {
+              return inferRuntimeType(
+                node.typeParameters.params[0],
+                declaredTypes
+              );
+            }
+            break;
         }
       }
-      return [`null`];
+      return [UNKNOWN_TYPE];
     case "TSParenthesizedType":
       return inferRuntimeType(node.typeAnnotation, declaredTypes);
     case "TSUnionType":
-      return [
-        ...new Set(
-          [].concat(
-            ...node.types.map((t) => inferRuntimeType(t, declaredTypes))
-          )
-        )
-      ];
-    case "TSIntersectionType":
-      return ["Object"];
+      return flattenTypes(node.types, declaredTypes);
+    case "TSIntersectionType": {
+      return flattenTypes(node.types, declaredTypes).filter(
+        (t) => t !== UNKNOWN_TYPE
+      );
+    }
     case "TSSymbolKeyword":
       return ["Symbol"];
     default:
-      return [`null`];
+      return [UNKNOWN_TYPE];
   }
 }
+function flattenTypes(types, declaredTypes) {
+  return [
+    ...new Set(
+      [].concat(
+        ...types.map((t) => inferRuntimeType(t, declaredTypes))
+      )
+    )
+  ];
+}
 function toRuntimeTypeString(types) {
   return types.length > 1 ? `[${types.join(", ")}]` : types[0];
 }
+function inferEnumType(node) {
+  const types = /* @__PURE__ */ new Set();
+  for (const m of node.members) {
+    if (m.initializer) {
+      switch (m.initializer.type) {
+        case "StringLiteral":
+          types.add("String");
+          break;
+        case "NumericLiteral":
+          types.add("Number");
+          break;
+      }
+    }
+  }
+  return types.size ? [...types] : ["Number"];
+}
+function inferValueType(node) {
+  switch (node.type) {
+    case "StringLiteral":
+      return "String";
+    case "NumericLiteral":
+      return "Number";
+    case "BooleanLiteral":
+      return "Boolean";
+    case "ObjectExpression":
+      return "Object";
+    case "ArrayExpression":
+      return "Array";
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+      return "Function";
+  }
+}
 function extractRuntimeEmits(node, emits) {
   if (node.type === "TSTypeLiteral" || node.type === "TSInterfaceBody") {
     const members = node.type === "TSTypeLiteral" ? node.members : node.body;
@@ -4768,11 +5113,8 @@ function genRuntimeEmits(emits) {
   return emits.size ? `
   emits: [${Array.from(emits).map((p) => JSON.stringify(p)).join(", ")}],` : ``;
 }
-function isCallOf(node, test) {
-  return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
-}
 function canNeverBeRef(node, userReactiveImport) {
-  if (isCallOf(node, userReactiveImport)) {
+  if (CompilerDOM.isCallOf(node, userReactiveImport)) {
     return true;
   }
   switch (node.type) {
@@ -4792,12 +5134,40 @@ function canNeverBeRef(node, userReactiveImport) {
         userReactiveImport
       );
     default:
-      if (node.type.endsWith("Literal")) {
+      if (isLiteralNode(node)) {
+        return true;
+      }
+      return false;
+  }
+}
+function isStaticNode(node) {
+  switch (node.type) {
+    case "UnaryExpression":
+      return isStaticNode(node.argument);
+    case "LogicalExpression":
+    case "BinaryExpression":
+      return isStaticNode(node.left) && isStaticNode(node.right);
+    case "ConditionalExpression": {
+      return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate);
+    }
+    case "SequenceExpression":
+    case "TemplateLiteral":
+      return node.expressions.every((expr) => isStaticNode(expr));
+    case "ParenthesizedExpression":
+    case "TSNonNullExpression":
+    case "TSAsExpression":
+    case "TSTypeAssertion":
+      return isStaticNode(node.expression);
+    default:
+      if (isLiteralNode(node)) {
         return true;
       }
       return false;
   }
 }
+function isLiteralNode(node) {
+  return node.type.endsWith("Literal");
+}
 function analyzeScriptBindings(ast) {
   for (const node of ast) {
     if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ObjectExpression") {
@@ -13910,6 +14280,7 @@ function preprocess(options, preprocessor) {
   );
 }
 
+const version = "3.3.0-alpha.6";
 const walk = estreeWalker.walk;
 
 exports.MagicString = MagicString;
@@ -13928,4 +14299,6 @@ exports.compileStyleAsync = compileStyleAsync;
 exports.compileTemplate = compileTemplate;
 exports.parse = parse$2;
 exports.rewriteDefault = rewriteDefault;
+exports.rewriteDefaultAST = rewriteDefaultAST;
+exports.version = version;
 exports.walk = walk;