@vue/compiler-sfc 3.1.0 → 3.1.4

package/dist/compiler-sfc.cjs.js

@@ -421,15 +421,9 @@ const defaultAssetUrlOptions = {
 const normalizeOptions = (options) => {
     if (Object.keys(options).some(key => shared.isArray(options[key]))) {
         // legacy option format which directly passes in tags config
-        return {
-            ...defaultAssetUrlOptions,
-            tags: options
-        };
+        return Object.assign(Object.assign({}, defaultAssetUrlOptions), { tags: options });
     }
-    return {
-        ...defaultAssetUrlOptions,
-        ...options
-    };
+    return Object.assign(Object.assign({}, defaultAssetUrlOptions), options);
 };
 const createAssetUrlTransformWithOptions = (options) => {
     return (node, context) => transformAssetUrl(node, context, options);
@@ -637,7 +631,7 @@ function preprocess({ source, filename, preprocessOptions }, preprocessor) {
     // have to be sync because they are applied via Node.js require hooks)
     let res = '';
     let err = null;
-    preprocessor.render(source, { filename, ...preprocessOptions }, (_err, _res) => {
+    preprocessor.render(source, Object.assign({ filename }, preprocessOptions), (_err, _res) => {
         if (_err)
             err = _err;
         res = _res;
@@ -655,10 +649,7 @@ function compileTemplate(options) {
         : false;
     if (preprocessor) {
         try {
-            return doCompileTemplate({
-                ...options,
-                source: preprocess(options, preprocessor)
-            });
+            return doCompileTemplate(Object.assign(Object.assign({}, options), { source: preprocess(options, preprocessor) }));
         }
         catch (e) {
             return {
@@ -709,23 +700,9 @@ function doCompileTemplate({ filename, id, scoped, slotted, inMap, source, ssr =
     }
     const shortId = id.replace(/^data-v-/, '');
     const longId = `data-v-${shortId}`;
-    let { code, ast, preamble, map } = compiler.compile(source, {
-        mode: 'module',
-        prefixIdentifiers: true,
-        hoistStatic: true,
-        cacheHandlers: true,
-        ssrCssVars: ssr && ssrCssVars && ssrCssVars.length
+    let { code, ast, preamble, map } = compiler.compile(source, Object.assign(Object.assign({ mode: 'module', prefixIdentifiers: true, hoistStatic: true, cacheHandlers: true, ssrCssVars: ssr && ssrCssVars && ssrCssVars.length
             ? genCssVarsFromList(ssrCssVars, shortId, isProd)
-            : '',
-        scopeId: scoped ? longId : undefined,
-        slotted,
-        ...compilerOptions,
-        nodeTransforms: nodeTransforms.concat(compilerOptions.nodeTransforms || []),
-        filename,
-        sourceMap: true,
-        onError: e => errors.push(e),
-        onWarn: w => warnings.push(w)
-    });
+            : '', scopeId: scoped ? longId : undefined, slotted }, compilerOptions), { nodeTransforms: nodeTransforms.concat(compilerOptions.nodeTransforms || []), filename, sourceMap: true, onError: e => errors.push(e), onWarn: w => warnings.push(w) }));
     // inMap should be the map produced by ./parse.ts which is a simple line-only
     // mapping. If it is present, we need to adjust the final map and errors to
     // reflect the original line numbers.
@@ -1002,13 +979,7 @@ scopedPlugin.postcss = true;
 // .scss/.sass processor
 const scss = (source, map, options, load = require) => {
     const nodeSass = load('sass');
-    const finalOptions = {
-        ...options,
-        data: getSource(source, options.filename, options.additionalData),
-        file: options.filename,
-        outFile: options.filename,
-        sourceMap: !!map
-    };
+    const finalOptions = Object.assign(Object.assign({}, options), { data: getSource(source, options.filename, options.additionalData), file: options.filename, outFile: options.filename, sourceMap: !!map });
     try {
         const result = nodeSass.renderSync(finalOptions);
         const dependencies = result.stats.includedFiles;
@@ -1026,16 +997,13 @@ const scss = (source, map, options, load = require) => {
         return { code: '', errors: [e], dependencies: [] };
     }
 };
-const sass = (source, map, options, load) => scss(source, map, {
-    ...options,
-    indentedSyntax: true
-}, load);
+const sass = (source, map, options, load) => scss(source, map, Object.assign(Object.assign({}, options), { indentedSyntax: true }), load);
 // .less
 const less = (source, map, options, load = require) => {
     const nodeLess = load('less');
     let result;
     let error = null;
-    nodeLess.render(getSource(source, options.filename, options.additionalData), { ...options, syncImport: true }, (err, output) => {
+    nodeLess.render(getSource(source, options.filename, options.additionalData), Object.assign(Object.assign({}, options), { syncImport: true }), (err, output) => {
         error = err;
         result = output;
     });
@@ -1097,13 +1065,10 @@ const processors = {
 };
 
 function compileStyle(options) {
-    return doCompileStyle({
-        ...options,
-        isAsync: false
-    });
+    return doCompileStyle(Object.assign(Object.assign({}, options), { isAsync: false }));
 }
 function compileStyleAsync(options) {
-    return doCompileStyle({ ...options, isAsync: true });
+    return doCompileStyle(Object.assign(Object.assign({}, options), { isAsync: true }));
 }
 function doCompileStyle(options) {
     const { filename, id, scoped = false, trim = true, isProd = false, modules = false, modulesOptions = {}, preprocessLang, postcssOptions, postcssPlugins } = options;
@@ -1128,18 +1093,11 @@ function doCompileStyle(options) {
         if (!options.isAsync) {
             throw new Error('[@vue/compiler-sfc] `modules` option can only be used with compileStyleAsync().');
         }
-        plugins.push(require('postcss-modules')({
-            ...modulesOptions,
-            getJSON: (_cssFileName, json) => {
+        plugins.push(require('postcss-modules')(Object.assign(Object.assign({}, modulesOptions), { getJSON: (_cssFileName, json) => {
                 cssModules = json;
-            }
-        }));
+            } })));
     }
-    const postCSSOptions = {
-        ...postcssOptions,
-        to: filename,
-        from: filename
-    };
+    const postCSSOptions = Object.assign(Object.assign({}, postcssOptions), { to: filename, from: filename });
     if (map) {
         postCSSOptions.map = {
             inline: false,
@@ -1205,14 +1163,11 @@ function doCompileStyle(options) {
     };
 }
 function preprocess$1(options, preprocessor) {
-    return preprocessor(options.source, options.inMap || options.map, {
-        filename: options.filename,
-        ...options.preprocessOptions
-    }, options.preprocessCustomRequire);
+    return preprocessor(options.source, options.inMap || options.map, Object.assign({ filename: options.filename }, options.preprocessOptions), options.preprocessCustomRequire);
 }
 
 const defaultExportRE = /((?:^|\n|;)\s*)export(\s*)default/;
-const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)as(\s*)default/;
+const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)as(\s*)default/s;
 const exportDefaultClassRE = /((?:^|\n|;)\s*)export\s+default\s+class\s+([\w$]+)/;
 /**
  * Utility for rewriting `export default` in a script block into a variable
@@ -1266,15 +1221,32 @@ function hasDefaultExport(input) {
 
 const DEFINE_PROPS = 'defineProps';
 const DEFINE_EMIT = 'defineEmit';
+const DEFINE_EXPOSE = 'defineExpose';
+const WITH_DEFAULTS = 'withDefaults';
+// deprecated
+const DEFINE_EMITS = 'defineEmits';
 /**
  * Compile `<script setup>`
  * It requires the whole SFC descriptor because we need to handle and merge
  * normal `<script>` + `<script setup>` if both are present.
  */
 function compileScript(sfc, options) {
-    const { script, scriptSetup, source, filename } = sfc;
+    let { script, scriptSetup, source, filename } = sfc;
+    // feature flags
+    const enableRefSugar = !!options.refSugar;
+    const parseOnly = !!options.parseOnly;
     if (scriptSetup) {
-        warnExperimental(`<script setup>`, 227);
+        !parseOnly && warnExperimental(`<script setup>`, 227);
+    }
+    else if (parseOnly) {
+        // in parse-only mode, construct a fake script setup so we still perform
+        // the full parse logic.
+        scriptSetup = {
+            type: 'script',
+            content: '',
+            attrs: {},
+            loc: compilerCore.locStub
+        };
     }
     // for backwards compat
     if (!options) {
@@ -1285,9 +1257,14 @@ function compileScript(sfc, options) {
             `Upgrade your vite or vue-loader version for compatibility with ` +
             `the latest experimental proposals.`);
     }
+    // TODO remove on 3.2
+    if (sfc.template && sfc.template.attrs['inherit-attrs'] === 'false') {
+        warnOnce(`experimetnal support for <template inherit-attrs="false"> support has ` +
+            `been removed. Use a <script> block with \`export default\` to ` +
+            `declare options.`);
+    }
     const scopeId = options.id ? options.id.replace(/^data-v-/, '') : '';
     const cssVars = sfc.cssVars;
-    const hasInheritAttrsFlag = sfc.template && sfc.template.attrs['inherit-attrs'] === 'false';
     const scriptLang = script && script.lang;
     const scriptSetupLang = scriptSetup && scriptSetup.lang;
     const isTS = scriptLang === 'ts' ||
@@ -1310,27 +1287,21 @@ function compileScript(sfc, options) {
         try {
             const scriptAst = parser.parse(script.content, {
                 plugins,
-                sourceType: 'module'
+                sourceType: 'module',
+                errorRecovery: parseOnly
             }).program.body;
             const bindings = analyzeScriptBindings(scriptAst);
-            const needRewrite = cssVars.length || hasInheritAttrsFlag;
             let content = script.content;
-            if (needRewrite) {
+            if (cssVars.length) {
                 content = rewriteDefault(content, `__default__`, plugins);
                 if (cssVars.length) {
                     content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, !!options.isProd);
                 }
-                if (hasInheritAttrsFlag) {
-                    content += `__default__.inheritAttrs = false`;
-                }
                 content += `\nexport default __default__`;
             }
-            return {
-                ...script,
-                content,
+            return Object.assign(Object.assign({}, script), { content,
                 bindings,
-                scriptAst
-            };
+                scriptAst });
         }
         catch (e) {
             // silently fallback if parse fails since user may be using custom
@@ -1339,29 +1310,40 @@ function compileScript(sfc, options) {
         }
     }
     if (script && scriptLang !== scriptSetupLang) {
-        throw new Error(`[@vue/compiler-sfc] <script> and <script setup> must have the same language type.`);
+        throw new Error(`[@vue/compiler-sfc] <script> and <script setup> must have the same ` +
+            `language type.`);
     }
     if (scriptSetupLang && !isTS && scriptSetupLang !== 'jsx') {
         // do not process non js/ts script blocks
         return scriptSetup;
     }
-    const defaultTempVar = `__default__`;
+    // metadata that needs to be returned
     const bindingMetadata = {};
+    const ranges = parseOnly
+        ? {
+            scriptBindings: [],
+            scriptSetupBindings: []
+        }
+        : undefined;
+    const defaultTempVar = `__default__`;
     const helperImports = new Set();
     const userImports = Object.create(null);
     const userImportAlias = Object.create(null);
     const setupBindings = Object.create(null);
     const refBindings = Object.create(null);
     const refIdentifiers = new Set();
-    const enableRefSugar = options.refSugar !== false;
     let defaultExport;
     let hasDefinePropsCall = false;
     let hasDefineEmitCall = false;
+    let hasDefineExposeCall = false;
     let propsRuntimeDecl;
+    let propsRuntimeDefaults;
     let propsTypeDecl;
+    let propsTypeDeclRaw;
     let propsIdentifier;
-    let emitRuntimeDecl;
-    let emitTypeDecl;
+    let emitsRuntimeDecl;
+    let emitsTypeDecl;
+    let emitsTypeDeclRaw;
     let emitIdentifier;
     let hasAwait = false;
     let hasInlinedSsrRenderFn = false;
@@ -1382,6 +1364,7 @@ function compileScript(sfc, options) {
     }
     function parse(input, options, offset) {
         try {
+            options.errorRecovery = parseOnly;
             return parser.parse(input, options).program.body;
         }
         catch (e) {
@@ -1392,63 +1375,116 @@ function compileScript(sfc, options) {
     function error(msg, node, end = node.end + startOffset) {
         throw new Error(`[@vue/compiler-sfc] ${msg}\n\n${sfc.filename}\n${shared.generateCodeFrame(source, node.start + startOffset, end)}`);
     }
-    function registerUserImport(source, local, imported, isType) {
+    function registerUserImport(source, local, imported, isType, isFromSetup, rangeNode) {
         if (source === 'vue' && imported) {
             userImportAlias[imported] = local;
         }
         userImports[local] = {
             isType,
             imported: imported || 'default',
-            source
+            source,
+            rangeNode,
+            isFromSetup
         };
     }
     function processDefineProps(node) {
-        if (isCallOf(node, DEFINE_PROPS)) {
-            if (hasDefinePropsCall) {
-                error(`duplicate ${DEFINE_PROPS}() call`, node);
-            }
-            hasDefinePropsCall = true;
-            propsRuntimeDecl = node.arguments[0];
-            // context call has type parameters - infer runtime types from it
-            if (node.typeParameters) {
-                if (propsRuntimeDecl) {
-                    error(`${DEFINE_PROPS}() cannot accept both type and non-type arguments ` +
-                        `at the same time. Use one or the other.`, node);
-                }
-                const typeArg = node.typeParameters.params[0];
-                if (typeArg.type === 'TSTypeLiteral') {
-                    propsTypeDecl = typeArg;
-                }
-                else {
-                    error(`type argument passed to ${DEFINE_PROPS}() must be a literal type.`, typeArg);
-                }
+        if (!isCallOf(node, DEFINE_PROPS)) {
+            return false;
+        }
+        if (hasDefinePropsCall) {
+            error(`duplicate ${DEFINE_PROPS}() call`, node);
+        }
+        hasDefinePropsCall = true;
+        propsRuntimeDecl = node.arguments[0];
+        // call has type parameters - infer runtime types from it
+        if (node.typeParameters) {
+            if (propsRuntimeDecl) {
+                error(`${DEFINE_PROPS}() cannot accept both type and non-type arguments ` +
+                    `at the same time. Use one or the other.`, node);
+            }
+            propsTypeDeclRaw = node.typeParameters.params[0];
+            propsTypeDecl = resolveQualifiedType(propsTypeDeclRaw, node => node.type === 'TSTypeLiteral');
+            if (!propsTypeDecl) {
+                error(`type argument passed to ${DEFINE_PROPS}() must be a literal type, ` +
+                    `or a reference to an interface or literal type.`, propsTypeDeclRaw);
             }
-            return true;
         }
-        return false;
+        return true;
+    }
+    function processWithDefaults(node) {
+        if (!isCallOf(node, WITH_DEFAULTS)) {
+            return false;
+        }
+        if (processDefineProps(node.arguments[0])) {
+            if (propsRuntimeDecl) {
+                error(`${WITH_DEFAULTS} can only be used with type-based ` +
+                    `${DEFINE_PROPS} declaration.`, node);
+            }
+            propsRuntimeDefaults = node.arguments[1];
+        }
+        else {
+            error(`${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`, node.arguments[0] || node);
+        }
+        return true;
     }
-    function processDefineEmit(node) {
-        if (isCallOf(node, DEFINE_EMIT)) {
-            if (hasDefineEmitCall) {
-                error(`duplicate ${DEFINE_EMIT}() call`, node);
-            }
-            hasDefineEmitCall = true;
-            emitRuntimeDecl = node.arguments[0];
-            if (node.typeParameters) {
-                if (emitRuntimeDecl) {
-                    error(`${DEFINE_EMIT}() cannot accept both type and non-type arguments ` +
-                        `at the same time. Use one or the other.`, node);
+    function processDefineEmits(node) {
+        if (!isCallOf(node, c => c === DEFINE_EMIT || c === DEFINE_EMITS)) {
+            return false;
+        }
+        if (hasDefineEmitCall) {
+            error(`duplicate ${DEFINE_EMITS}() call`, node);
+        }
+        hasDefineEmitCall = true;
+        emitsRuntimeDecl = node.arguments[0];
+        if (node.typeParameters) {
+            if (emitsRuntimeDecl) {
+                error(`${DEFINE_EMIT}() cannot accept both type and non-type arguments ` +
+                    `at the same time. Use one or the other.`, node);
+            }
+            emitsTypeDeclRaw = node.typeParameters.params[0];
+            emitsTypeDecl = resolveQualifiedType(emitsTypeDeclRaw, node => node.type === 'TSFunctionType' || node.type === 'TSTypeLiteral');
+            if (!emitsTypeDecl) {
+                error(`type argument passed to ${DEFINE_EMITS}() must be a function type, ` +
+                    `a literal type with call signatures, or a reference to the above types.`, emitsTypeDeclRaw);
+            }
+        }
+        return true;
+    }
+    function resolveQualifiedType(node, qualifier) {
+        if (qualifier(node)) {
+            return node;
+        }
+        if (node.type === 'TSTypeReference' &&
+            node.typeName.type === 'Identifier') {
+            const refName = node.typeName.name;
+            const isQualifiedType = (node) => {
+                if (node.type === 'TSInterfaceDeclaration' &&
+                    node.id.name === refName) {
+                    return node.body;
                 }
-                const typeArg = node.typeParameters.params[0];
-                if (typeArg.type === 'TSFunctionType' ||
-                    typeArg.type === 'TSTypeLiteral') {
-                    emitTypeDecl = typeArg;
+                else if (node.type === 'TSTypeAliasDeclaration' &&
+                    node.id.name === refName &&
+                    qualifier(node.typeAnnotation)) {
+                    return node.typeAnnotation;
                 }
-                else {
-                    error(`type argument passed to ${DEFINE_EMIT}() must be a function type ` +
-                        `or a literal type with call signatures.`, typeArg);
+                else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+                    return isQualifiedType(node.declaration);
+                }
+            };
+            for (const node of scriptSetupAst) {
+                const qualified = isQualifiedType(node);
+                if (qualified) {
+                    return qualified;
                 }
             }
+        }
+    }
+    function processDefineExpose(node) {
+        if (isCallOf(node, DEFINE_EXPOSE)) {
+            if (hasDefineExposeCall) {
+                error(`duplicate ${DEFINE_EXPOSE}() call`, node);
+            }
+            hasDefineExposeCall = true;
             return true;
         }
         return false;
@@ -1513,7 +1549,10 @@ function compileScript(sfc, options) {
         if (id.name[0] === '$') {
             error(`ref variable identifiers cannot start with $.`, id);
         }
-        refBindings[id.name] = setupBindings[id.name] = "setup-ref" /* SETUP_REF */;
+        refBindings[id.name] = setupBindings[id.name] = {
+            type: "setup-ref" /* SETUP_REF */,
+            rangeNode: id
+        };
         refIdentifiers.add(id);
     }
     function processRefObjectPattern(pattern, statement) {
@@ -1592,6 +1631,39 @@ function compileScript(sfc, options) {
             }
         }
     }
+    function genRuntimeProps(props) {
+        const keys = Object.keys(props);
+        if (!keys.length) {
+            return ``;
+        }
+        // check defaults. If the default object is an object literal with only
+        // static properties, we can directly generate more optimzied default
+        // decalrations. Otherwise we will have to fallback to runtime merging.
+        const hasStaticDefaults = propsRuntimeDefaults &&
+            propsRuntimeDefaults.type === 'ObjectExpression' &&
+            propsRuntimeDefaults.properties.every(node => node.type === 'ObjectProperty' && !node.computed);
+        let propsDecls = `{
+    ${keys
+            .map(key => {
+            let defaultString;
+            if (hasStaticDefaults) {
+                const prop = propsRuntimeDefaults.properties.find((node) => node.key.name === key);
+                if (prop) {
+                    // prop has corresponding static default value
+                    defaultString = `default: ${source.slice(prop.value.start + startOffset, prop.value.end + startOffset)}`;
+                }
+            }
+            {
+                const { type, required } = props[key];
+                return `${key}: { type: ${toRuntimeTypeString(type)}, required: ${required}${defaultString ? `, ${defaultString}` : ``} }`;
+            }
+        })
+            .join(',\n    ')}\n  }`;
+        if (propsRuntimeDefaults && !hasStaticDefaults) {
+            propsDecls = `${helper('mergeDefaults')}(${propsDecls}, ${source.slice(propsRuntimeDefaults.start + startOffset, propsRuntimeDefaults.end + startOffset)})`;
+        }
+        return `\n  props: ${propsDecls} as unknown as undefined,`;
+    }
     // 1. process normal <script> first if it exists
     let scriptAst;
     if (script) {
@@ -1607,7 +1679,7 @@ function compileScript(sfc, options) {
                     const imported = specifier.type === 'ImportSpecifier' &&
                         specifier.imported.type === 'Identifier' &&
                         specifier.imported.name;
-                    registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === 'type');
+                    registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === 'type', false, specifier.local);
                 }
             }
             else if (node.type === 'ExportDefaultDeclaration') {
@@ -1654,7 +1726,6 @@ function compileScript(sfc, options) {
     for (const node of scriptSetupAst) {
         const start = node.start + startOffset;
         let end = node.end + startOffset;
-        // import or type declarations: move to top
         // locate comment
         if (node.trailingComments && node.trailingComments.length > 0) {
             const lastCommentNode = node.trailingComments[node.trailingComments.length - 1];
@@ -1672,14 +1743,15 @@ function compileScript(sfc, options) {
             node.label.name === 'ref' &&
             node.body.type === 'ExpressionStatement') {
             if (enableRefSugar) {
-                warnExperimental(`ref: sugar`, 228);
+                !parseOnly && warnExperimental(`ref: sugar`, 228);
                 s.overwrite(node.label.start + startOffset, node.body.start + startOffset, 'const ');
                 processRefExpression(node.body.expression, node);
             }
             else {
-                // TODO if we end up shipping ref: sugar as an opt-in feature,
-                // need to proxy the option in vite, vue-loader and rollup-plugin-vue.
-                error(`ref: sugar needs to be explicitly enabled via vite or vue-loader options.`, node);
+                error(`ref: sugar now needs to be explicitly enabled via @vitejs/plugin-vue ` +
+                    `or vue-loader options:\n` +
+                    `- @vitejs/plugin-vue: via \`script.refSugar\`\n` +
+                    `- vue-loader: via \`refSugar\` (requires 16.3.0+)`, node);
             }
         }
         if (node.type === 'ImportDeclaration') {
@@ -1707,7 +1779,11 @@ function compileScript(sfc, options) {
                 const source = node.source.value;
                 const existing = userImports[local];
                 if (source === 'vue' &&
-                    (imported === DEFINE_PROPS || imported === DEFINE_EMIT)) {
+                    (imported === DEFINE_PROPS ||
+                        imported === DEFINE_EMIT ||
+                        imported === DEFINE_EMITS ||
+                        imported === DEFINE_EXPOSE)) {
+                    warnOnce(`\`${imported}\` is a compiler macro and no longer needs to be imported.`);
                     removeSpecifier(i);
                 }
                 else if (existing) {
@@ -1720,36 +1796,57 @@ function compileScript(sfc, options) {
                     }
                 }
                 else {
-                    registerUserImport(source, local, imported, node.importKind === 'type');
+                    registerUserImport(source, local, imported, node.importKind === 'type', true, specifier.local);
                 }
             }
             if (node.specifiers.length && removed === node.specifiers.length) {
                 s.remove(node.start + startOffset, node.end + startOffset);
             }
         }
-        // process `defineProps` and `defineEmit` calls
-        if (node.type === 'ExpressionStatement' &&
-            (processDefineProps(node.expression) ||
-                processDefineEmit(node.expression))) {
-            s.remove(node.start + startOffset, node.end + startOffset);
+        if (node.type === 'ExpressionStatement') {
+            // process `defineProps` and `defineEmit(s)` calls
+            if (processDefineProps(node.expression) ||
+                processDefineEmits(node.expression) ||
+                processWithDefaults(node.expression)) {
+                s.remove(node.start + startOffset, node.end + startOffset);
+            }
+            else if (processDefineExpose(node.expression)) {
+                // defineExpose({}) -> expose({})
+                const callee = node.expression.callee;
+                s.overwrite(callee.start + startOffset, callee.end + startOffset, 'expose');
+            }
         }
         if (node.type === 'VariableDeclaration' && !node.declare) {
-            for (const decl of node.declarations) {
+            const total = node.declarations.length;
+            let left = total;
+            for (let i = 0; i < total; i++) {
+                const decl = node.declarations[i];
                 if (decl.init) {
-                    const isDefineProps = processDefineProps(decl.init);
+                    const isDefineProps = processDefineProps(decl.init) || processWithDefaults(decl.init);
                     if (isDefineProps) {
                         propsIdentifier = scriptSetup.content.slice(decl.id.start, decl.id.end);
                     }
-                    const isDefineEmit = processDefineEmit(decl.init);
-                    if (isDefineEmit) {
+                    const isDefineEmits = processDefineEmits(decl.init);
+                    if (isDefineEmits) {
                         emitIdentifier = scriptSetup.content.slice(decl.id.start, decl.id.end);
                     }
-                    if (isDefineProps || isDefineEmit)
-                        if (node.declarations.length === 1) {
+                    if (isDefineProps || isDefineEmits)
+                        if (left === 1) {
                             s.remove(node.start + startOffset, node.end + startOffset);
                         }
                         else {
-                            s.remove(decl.start + startOffset, decl.end + startOffset);
+                            let start = decl.start + startOffset;
+                            let end = decl.end + startOffset;
+                            if (i < total - 1) {
+                                // not the last one, locate the start of the next
+                                end = node.declarations[i + 1].start + startOffset;
+                            }
+                            else {
+                                // last one, locate the end of the prev
+                                start = node.declarations[i - 1].end + startOffset;
+                            }
+                            s.remove(start, end);
+                            left--;
                         }
                 }
             }
@@ -1761,16 +1858,6 @@ function compileScript(sfc, options) {
             !node.declare) {
             walkDeclaration(node, setupBindings, userImportAlias);
         }
-        // Type declarations
-        if (node.type === 'VariableDeclaration' && node.declare) {
-            s.remove(start, end);
-        }
-        // move all type declarations to outer scope
-        if (node.type.startsWith('TS') ||
-            (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type')) {
-            recordType(node, declaredTypes);
-            s.move(start, end, 0);
-        }
         // walk statements & named exports / variable declarations for top level
         // await
         if ((node.type === 'VariableDeclaration' && !node.declare) ||
@@ -1782,6 +1869,8 @@ function compileScript(sfc, options) {
                     }
                     if (node.type === 'AwaitExpression') {
                         hasAwait = true;
+                        s.prependRight(node.argument.start + startOffset, helper(`withAsyncContext`) + `(`);
+                        s.appendLeft(node.argument.end + startOffset, `)`);
                     }
                 }
             });
@@ -1793,6 +1882,52 @@ function compileScript(sfc, options) {
                 `If you are using a previous version of <script setup>, please ` +
                 `consult the updated RFC at https://github.com/vuejs/rfcs/pull/227.`, node);
         }
+        if (isTS) {
+            // runtime enum
+            if (node.type === 'TSEnumDeclaration' && !node.const) {
+                registerBinding(setupBindings, node.id, "setup-const" /* SETUP_CONST */);
+            }
+            // move all Type declarations to outer scope
+            if (node.type.startsWith('TS') ||
+                (node.type === 'ExportNamedDeclaration' &&
+                    node.exportKind === 'type') ||
+                (node.type === 'VariableDeclaration' && node.declare)) {
+                recordType(node, declaredTypes);
+                s.move(start, end, 0);
+            }
+        }
+    }
+    // in parse only mode, we should have collected all the information we need,
+    // return early.
+    if (parseOnly) {
+        for (const key in userImports) {
+            const { rangeNode, isFromSetup } = userImports[key];
+            const bindings = isFromSetup
+                ? ranges.scriptSetupBindings
+                : ranges.scriptBindings;
+            bindings.push(toTextRange(rangeNode));
+        }
+        for (const key in setupBindings) {
+            ranges.scriptSetupBindings.push(toTextRange(setupBindings[key].rangeNode));
+        }
+        if (propsRuntimeDecl) {
+            ranges.propsRuntimeArg = toTextRange(propsRuntimeDecl);
+        }
+        if (propsTypeDeclRaw) {
+            ranges.propsTypeArg = toTextRange(propsTypeDeclRaw);
+        }
+        if (emitsRuntimeDecl) {
+            ranges.emitsRuntimeArg = toTextRange(emitsRuntimeDecl);
+        }
+        if (emitsTypeDeclRaw) {
+            ranges.emitsTypeArg = toTextRange(emitsTypeDeclRaw);
+        }
+        if (propsRuntimeDefaults) {
+            ranges.withDefaultsArg = toTextRange(propsRuntimeDefaults);
+        }
+        return Object.assign(Object.assign({}, scriptSetup), { ranges,
+            scriptAst,
+            scriptSetupAst });
     }
     // 3. Do a full walk to rewrite identifiers referencing let exports with ref
     // value access
@@ -1826,13 +1961,14 @@ function compileScript(sfc, options) {
     if (propsTypeDecl) {
         extractRuntimeProps(propsTypeDecl, typeDeclaredProps, declaredTypes);
     }
-    if (emitTypeDecl) {
-        extractRuntimeEmits(emitTypeDecl, typeDeclaredEmits);
+    if (emitsTypeDecl) {
+        extractRuntimeEmits(emitsTypeDecl, typeDeclaredEmits);
     }
     // 5. check useOptions args to make sure it doesn't reference setup scope
     // variables
     checkInvalidScopeReference(propsRuntimeDecl, DEFINE_PROPS);
-    checkInvalidScopeReference(emitRuntimeDecl, DEFINE_PROPS);
+    checkInvalidScopeReference(propsRuntimeDefaults, DEFINE_PROPS);
+    checkInvalidScopeReference(emitsRuntimeDecl, DEFINE_PROPS);
     // 6. remove non-script content
     if (script) {
         if (startOffset < scriptStartOffset) {
@@ -1874,7 +2010,7 @@ function compileScript(sfc, options) {
                 : "setup-maybe-ref" /* SETUP_MAYBE_REF */;
     }
     for (const key in setupBindings) {
-        bindingMetadata[key] = setupBindings[key];
+        bindingMetadata[key] = setupBindings[key].type;
     }
     // 8. inject `useCssVars` calls
     if (cssVars.length) {
@@ -1893,15 +2029,14 @@ function compileScript(sfc, options) {
     if (propsIdentifier) {
         s.prependRight(startOffset, `\nconst ${propsIdentifier} = __props`);
     }
+    const destructureElements = hasDefineExposeCall || !options.inlineTemplate ? [`expose`] : [];
     if (emitIdentifier) {
-        args +=
-            emitIdentifier === `emit` ? `, { emit }` : `, { emit: ${emitIdentifier} }`;
-        if (emitTypeDecl) {
-            args += `: {
-        emit: (${scriptSetup.content.slice(emitTypeDecl.start, emitTypeDecl.end)}),
-        slots: any,
-        attrs: any
-      }`;
+        destructureElements.push(emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`);
+    }
+    if (destructureElements.length) {
+        args += `, { ${destructureElements.join(', ')} }`;
+        if (emitsTypeDecl) {
+            args += `: { emit: (${scriptSetup.content.slice(emitsTypeDecl.start, emitsTypeDecl.end)}), expose: any, slots: any, attrs: any }`;
         }
     }
     // 10. generate return statement
@@ -1913,23 +2048,9 @@ function compileScript(sfc, options) {
             }
             // inline render function mode - we are going to compile the template and
             // inline it right here
-            const { code, ast, preamble, tips, errors } = compileTemplate({
-                filename,
-                source: sfc.template.content,
-                inMap: sfc.template.map,
-                ...options.templateOptions,
-                id: scopeId,
-                scoped: sfc.styles.some(s => s.scoped),
-                isProd: options.isProd,
-                ssrCssVars: sfc.cssVars,
-                compilerOptions: {
-                    ...(options.templateOptions &&
-                        options.templateOptions.compilerOptions),
-                    inline: true,
-                    isTS,
-                    bindingMetadata
-                }
-            });
+            const { code, ast, preamble, tips, errors } = compileTemplate(Object.assign(Object.assign({ filename, source: sfc.template.content, inMap: sfc.template.map }, options.templateOptions), { id: scopeId, scoped: sfc.styles.some(s => s.scoped), isProd: options.isProd, ssrCssVars: sfc.cssVars, compilerOptions: Object.assign(Object.assign({}, (options.templateOptions &&
+                    options.templateOptions.compilerOptions)), { inline: true, isTS,
+                    bindingMetadata }) }));
             if (tips.length) {
                 tips.forEach(warnOnce);
             }
@@ -1965,7 +2086,7 @@ function compileScript(sfc, options) {
     }
     else {
         // return bindings from setup
-        const allBindings = { ...setupBindings };
+        const allBindings = Object.assign({}, setupBindings);
         for (const key in userImports) {
             if (!userImports[key].isType) {
                 allBindings[key] = true;
@@ -1973,13 +2094,19 @@ function compileScript(sfc, options) {
         }
         returned = `{ ${Object.keys(allBindings).join(', ')} }`;
     }
-    s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`);
-    // 11. finalize default export
-    // expose: [] makes <script setup> components "closed" by default.
-    let runtimeOptions = `\n  expose: [],`;
-    if (hasInheritAttrsFlag) {
-        runtimeOptions += `\n  inheritAttrs: false,`;
+    if (!options.inlineTemplate && !false) {
+        // in non-inline mode, the `__isScriptSetup: true` flag is used by
+        // componentPublicInstance proxy to allow properties that start with $ or _
+        s.appendRight(endOffset, `\nconst __returned__ = ${returned}\n` +
+            `Object.defineProperty(__returned__, '__isScriptSetup', { enumerable: false, value: true })\n` +
+            `return __returned__` +
+            `\n}\n\n`);
     }
+    else {
+        s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`);
+    }
+    // 11. finalize default export
+    let runtimeOptions = ``;
     if (hasInlinedSsrRenderFn) {
         runtimeOptions += `\n  __ssrInlineRender: true,`;
     }
@@ -1991,14 +2118,17 @@ function compileScript(sfc, options) {
     else if (propsTypeDecl) {
         runtimeOptions += genRuntimeProps(typeDeclaredProps);
     }
-    if (emitRuntimeDecl) {
+    if (emitsRuntimeDecl) {
         runtimeOptions += `\n  emits: ${scriptSetup.content
-            .slice(emitRuntimeDecl.start, emitRuntimeDecl.end)
+            .slice(emitsRuntimeDecl.start, emitsRuntimeDecl.end)
             .trim()},`;
     }
-    else if (emitTypeDecl) {
+    else if (emitsTypeDecl) {
         runtimeOptions += genRuntimeEmits(typeDeclaredEmits);
     }
+    // <script setup> components are closed by default. If the user did not
+    // explicitly call `defineExpose`, call expose() with no args.
+    const exposeCall = hasDefineExposeCall || options.inlineTemplate ? `` : `  expose()\n`;
     if (isTS) {
         // for TS, make sure the exported type is still valid type with
         // correct props information
@@ -2008,7 +2138,7 @@ function compileScript(sfc, options) {
         // wrap setup code with function.
         // export the content of <script setup> as a named export, `setup`.
         // this allows `import { setup } from '*.vue'` for testing purposes.
-        s.prependLeft(startOffset, `\nexport default ${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n`);
+        s.prependLeft(startOffset, `\nexport default ${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
         s.appendRight(endOffset, `})`);
     }
     else {
@@ -2019,7 +2149,7 @@ function compileScript(sfc, options) {
         }
         else {
             s.prependLeft(startOffset, `\nexport default {${runtimeOptions}\n  ` +
-                `${hasAwait ? `async ` : ``}setup(${args}) {\n`);
+                `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
             s.appendRight(endOffset, `}`);
         }
     }
@@ -2030,17 +2160,17 @@ function compileScript(sfc, options) {
             .join(', ')} } from 'vue'\n`);
     }
     s.trim();
-    return {
-        ...scriptSetup,
-        bindings: bindingMetadata,
-        content: s.toString(),
-        map: s.generateMap({
+    return Object.assign(Object.assign({}, scriptSetup), { bindings: bindingMetadata, content: s.toString(), map: s.generateMap({
             source: filename,
             hires: true,
             includeContent: true
-        }),
-        scriptAst,
-        scriptSetupAst
+        }), scriptAst,
+        scriptSetupAst });
+}
+function registerBinding(bindings, node, type) {
+    bindings[node.name] = {
+        type,
+        rangeNode: node
     };
 }
 function walkDeclaration(node, bindings, userImportAlias) {
@@ -2049,7 +2179,10 @@ function walkDeclaration(node, bindings, userImportAlias) {
         // export const foo = ...
         for (const { id, init } of node.declarations) {
             const isDefineCall = !!(isConst &&
-                (isCallOf(init, DEFINE_PROPS) || isCallOf(init, DEFINE_EMIT)));
+                isCallOf(init, c => c === DEFINE_PROPS ||
+                    c === DEFINE_EMIT ||
+                    c === DEFINE_EMITS ||
+                    c === WITH_DEFAULTS));
             if (id.type === 'Identifier') {
                 let bindingType;
                 const userReactiveBinding = userImportAlias['reactive'] || 'reactive';
@@ -2075,7 +2208,7 @@ function walkDeclaration(node, bindings, userImportAlias) {
                 else {
                     bindingType = "setup-let" /* SETUP_LET */;
                 }
-                bindings[id.name] = bindingType;
+                registerBinding(bindings, id, bindingType);
             }
             else if (id.type === 'ObjectPattern') {
                 walkObjectPattern(id, bindings, isConst, isDefineCall);
@@ -2089,7 +2222,10 @@ function walkDeclaration(node, bindings, userImportAlias) {
         node.type === 'ClassDeclaration') {
         // export function foo() {} / export class Foo {}
         // export declarations must be named.
-        bindings[node.id.name] = "setup-const" /* SETUP_CONST */;
+        bindings[node.id.name] = {
+            type: "setup-const" /* SETUP_CONST */,
+            rangeNode: node.id
+        };
     }
 }
 function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
@@ -2099,11 +2235,12 @@ function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
             if (p.key.type === 'Identifier') {
                 if (p.key === p.value) {
                     // const { x } = ...
-                    bindings[p.key.name] = isDefineCall
+                    const type = isDefineCall
                         ? "setup-const" /* SETUP_CONST */
                         : isConst
                             ? "setup-maybe-ref" /* SETUP_MAYBE_REF */
                             : "setup-let" /* SETUP_LET */;
+                    registerBinding(bindings, p.key, type);
                 }
                 else {
                     walkPattern(p.value, bindings, isConst, isDefineCall);
@@ -2113,9 +2250,8 @@ function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
         else {
             // ...rest
             // argument can only be identifer when destructuring
-            bindings[p.argument.name] = isConst
-                ? "setup-const" /* SETUP_CONST */
-                : "setup-let" /* SETUP_LET */;
+            const type = isConst ? "setup-const" /* SETUP_CONST */ : "setup-let" /* SETUP_LET */;
+            registerBinding(bindings, p.argument, type);
         }
     }
 }
@@ -2126,17 +2262,17 @@ function walkArrayPattern(node, bindings, isConst, isDefineCall = false) {
 }
 function walkPattern(node, bindings, isConst, isDefineCall = false) {
     if (node.type === 'Identifier') {
-        bindings[node.name] = isDefineCall
+        const type = isDefineCall
             ? "setup-const" /* SETUP_CONST */
             : isConst
                 ? "setup-maybe-ref" /* SETUP_MAYBE_REF */
                 : "setup-let" /* SETUP_LET */;
+        registerBinding(bindings, node, type);
     }
     else if (node.type === 'RestElement') {
         // argument can only be identifer when destructuring
-        bindings[node.argument.name] = isConst
-            ? "setup-const" /* SETUP_CONST */
-            : "setup-let" /* SETUP_LET */;
+        const type = isConst ? "setup-const" /* SETUP_CONST */ : "setup-let" /* SETUP_LET */;
+        registerBinding(bindings, node.argument, type);
     }
     else if (node.type === 'ObjectPattern') {
         walkObjectPattern(node, bindings, isConst);
@@ -2146,11 +2282,12 @@ function walkPattern(node, bindings, isConst, isDefineCall = false) {
     }
     else if (node.type === 'AssignmentPattern') {
         if (node.left.type === 'Identifier') {
-            bindings[node.left.name] = isDefineCall
+            const type = isDefineCall
                 ? "setup-const" /* SETUP_CONST */
                 : isConst
                     ? "setup-maybe-ref" /* SETUP_MAYBE_REF */
                     : "setup-let" /* SETUP_LET */;
+            registerBinding(bindings, node.left, type);
         }
         else {
             walkPattern(node.left, bindings, isConst);
@@ -2169,14 +2306,23 @@ function recordType(node, declaredTypes) {
     }
 }
 function extractRuntimeProps(node, props, declaredTypes) {
-    for (const m of node.members) {
-        if (m.type === 'TSPropertySignature' && m.key.type === 'Identifier') {
+    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;
+            {
+                if (m.type === 'TSMethodSignature') {
+                    type = ['Function'];
+                }
+                else if (m.typeAnnotation) {
+                    type = inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes);
+                }
+            }
             props[m.key.name] = {
                 key: m.key.name,
                 required: !m.optional,
-                type: m.typeAnnotation
-                    ? inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes)
-                    : [`null`]
+                type: type || [`null`]
             };
         }
     }
@@ -2249,18 +2395,6 @@ function inferRuntimeType(node, declaredTypes) {
             return [`null`]; // no runtime check
     }
 }
-function genRuntimeProps(props) {
-    const keys = Object.keys(props);
-    if (!keys.length) {
-        return ``;
-    }
-    return `\n  props: {\n    ${keys
-        .map(key => {
-        const { type, required } = props[key];
-        return `${key}: { type: ${toRuntimeTypeString(type)}, required: ${required} }`;
-    })
-        .join(',\n    ')}\n  } as unknown as undefined,`;
-}
 function toRuntimeTypeString(types) {
     return types.some(t => t === 'null')
         ? `null`
@@ -2269,8 +2403,9 @@ function toRuntimeTypeString(types) {
             : types[0];
 }
 function extractRuntimeEmits(node, emits) {
-    if (node.type === 'TSTypeLiteral') {
-        for (let t of node.members) {
+    if (node.type === 'TSTypeLiteral' || node.type === 'TSInterfaceBody') {
+        const members = node.type === 'TSTypeLiteral' ? node.members : node.body;
+        for (let t of members) {
             if (t.type === 'TSCallSignatureDeclaration') {
                 extractEventNames(t.parameters[0], emits);
             }
@@ -2386,6 +2521,9 @@ function walkIdentifiers(root, onIdentifier) {
     });
 }
 function isRefIdentifier(id, parent, parentStack) {
+    if (!parent) {
+        return true;
+    }
     // declaration id
     if ((parent.type === 'VariableDeclarator' ||
         parent.type === 'ClassDeclaration') &&
@@ -2432,11 +2570,13 @@ const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent
 function isFunction(node) {
     return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
 }
-function isCallOf(node, name) {
+function isCallOf(node, test) {
     return !!(node &&
         node.type === 'CallExpression' &&
         node.callee.type === 'Identifier' &&
-        node.callee.name === name);
+        (typeof test === 'string'
+            ? node.callee.name === test
+            : test(node.callee.name)));
 }
 function canNeverBeRef(node, userReactiveImport) {
     if (isCallOf(node, userReactiveImport)) {
@@ -2627,6 +2767,12 @@ function extractIdentifiers(param, nodes = []) {
             break;
     }
     return nodes;
+}
+function toTextRange(node) {
+    return {
+        start: node.start,
+        end: node.end
+    };
 }
 
 exports.generateCodeFrame = compilerCore.generateCodeFrame;