@vue/compiler-sfc 2.7.0-alpha.8 → 2.7.0-beta.2

package/dist/compiler-sfc.d.ts

@@ -5,6 +5,144 @@ declare interface AssetURLOptions {
     [name: string]: string | string[];
 }
 
+declare type ASTAttr = {
+    name: string;
+    value: any;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTDirective = {
+    name: string;
+    rawName: string;
+    value: string;
+    arg: string | null;
+    isDynamicArg: boolean;
+    modifiers: ASTModifiers | null;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElement = {
+    type: 1;
+    tag: string;
+    attrsList: Array<ASTAttr>;
+    attrsMap: {
+        [key: string]: any;
+    };
+    rawAttrsMap: {
+        [key: string]: ASTAttr;
+    };
+    parent: ASTElement | void;
+    children: Array<ASTNode>;
+    start?: number;
+    end?: number;
+    processed?: true;
+    static?: boolean;
+    staticRoot?: boolean;
+    staticInFor?: boolean;
+    staticProcessed?: boolean;
+    hasBindings?: boolean;
+    text?: string;
+    attrs?: Array<ASTAttr>;
+    dynamicAttrs?: Array<ASTAttr>;
+    props?: Array<ASTAttr>;
+    plain?: boolean;
+    pre?: true;
+    ns?: string;
+    component?: string;
+    inlineTemplate?: true;
+    transitionMode?: string | null;
+    slotName?: string | null;
+    slotTarget?: string | null;
+    slotTargetDynamic?: boolean;
+    slotScope?: string | null;
+    scopedSlots?: {
+        [name: string]: ASTElement;
+    };
+    ref?: string;
+    refInFor?: boolean;
+    if?: string;
+    ifProcessed?: boolean;
+    elseif?: string;
+    else?: true;
+    ifConditions?: ASTIfConditions;
+    for?: string;
+    forProcessed?: boolean;
+    key?: string;
+    alias?: string;
+    iterator1?: string;
+    iterator2?: string;
+    staticClass?: string;
+    classBinding?: string;
+    staticStyle?: string;
+    styleBinding?: string;
+    events?: ASTElementHandlers;
+    nativeEvents?: ASTElementHandlers;
+    transition?: string | true;
+    transitionOnAppear?: boolean;
+    model?: {
+        value: string;
+        callback: string;
+        expression: string;
+    };
+    directives?: Array<ASTDirective>;
+    forbidden?: true;
+    once?: true;
+    onceProcessed?: boolean;
+    wrapData?: (code: string) => string;
+    wrapListeners?: (code: string) => string;
+    ssrOptimizability?: number;
+};
+
+declare type ASTElementHandler = {
+    value: string;
+    params?: Array<any>;
+    modifiers: ASTModifiers | null;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElementHandlers = {
+    [key: string]: ASTElementHandler | Array<ASTElementHandler>;
+};
+
+declare type ASTExpression = {
+    type: 2;
+    expression: string;
+    text: string;
+    tokens: Array<string | Object>;
+    static?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTIfCondition = {
+    exp: string | null;
+    block: ASTElement;
+};
+
+declare type ASTIfConditions = Array<ASTIfCondition>;
+
+declare type ASTModifiers = {
+    [key: string]: boolean;
+};
+
+declare type ASTNode = ASTElement | ASTText | ASTExpression;
+
+declare type ASTText = {
+    type: 3;
+    text: string;
+    static?: boolean;
+    isComment?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
 declare type BindingMetadata = {
     [key: string]: BindingTypes | undefined;
 } & {
@@ -53,18 +191,56 @@ declare const enum BindingTypes {
     OPTIONS = "options"
 }
 
+declare type CompiledResult = {
+    ast: ASTElement | null;
+    render: string;
+    staticRenderFns: Array<string>;
+    stringRenderFns?: Array<string>;
+    errors?: Array<string | WarningMessage>;
+    tips?: Array<string | WarningMessage>;
+};
+
+export declare type CompilerOptions = {
+    warn?: Function;
+    modules?: Array<ModuleOptions>;
+    directives?: {
+        [key: string]: Function;
+    };
+    staticKeys?: string;
+    isUnaryTag?: (tag: string) => boolean | undefined;
+    canBeLeftOpenTag?: (tag: string) => boolean | undefined;
+    isReservedTag?: (tag: string) => boolean | undefined;
+    preserveWhitespace?: boolean;
+    whitespace?: 'preserve' | 'condense';
+    optimize?: boolean;
+    mustUseProp?: (tag: string, type: string | null, name: string) => boolean;
+    isPreTag?: (attr: string) => boolean | null;
+    getTagNamespace?: (tag: string) => string | undefined;
+    expectHTML?: boolean;
+    isFromDOM?: boolean;
+    shouldDecodeTags?: boolean;
+    shouldDecodeNewlines?: boolean;
+    shouldDecodeNewlinesForHref?: boolean;
+    outputSourceRange?: boolean;
+    shouldKeepComment?: boolean;
+    delimiters?: [string, string];
+    comments?: boolean;
+    scopeId?: string;
+    bindings?: BindingMetadata;
+};
+
 /**
  * Compile `<script setup>`
  * It requires the whole SFC descriptor because we need to handle and merge
  * normal `<script>` + `<script setup>` if both are present.
  */
-export declare function compileScript(sfc: SFCDescriptor, options?: ScriptCompileOptions): SFCScriptBlock;
+export declare function compileScript(sfc: SFCDescriptor, options?: SFCScriptCompileOptions): SFCScriptBlock;
 
-export declare function compileStyle(options: StyleCompileOptions): StyleCompileResults;
+export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
 
-export declare function compileStyleAsync(options: StyleCompileOptions): Promise<StyleCompileResults>;
+export declare function compileStyleAsync(options: SFCStyleCompileOptions): Promise<SFCStyleCompileResults>;
 
-export declare function compileTemplate(options: TemplateCompileOptions): TemplateCompileResult;
+export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
 
 export declare function generateCodeFrame(source: string, start?: number, end?: number): string;
 
@@ -76,15 +252,24 @@ declare interface ImportBinding {
     isUsedInTemplate: boolean;
 }
 
+declare type ModuleOptions = {
+    preTransformNode?: (el: ASTElement) => ASTElement | null | void;
+    transformNode?: (el: ASTElement) => ASTElement | null | void;
+    postTransformNode?: (el: ASTElement) => void;
+    genData?: (el: ASTElement) => string;
+    transformCode?: (el: ASTElement, code: string) => string;
+    staticKeys?: Array<string>;
+};
+
 export declare function parse(options: ParseOptions): SFCDescriptor;
 
 declare interface ParseOptions {
     source: string;
     filename?: string;
-    compiler?: VueTemplateCompiler;
+    compiler?: TemplateCompiler;
     compilerParseOptions?: VueTemplateCompilerParseOptions;
     sourceRoot?: string;
-    needMap?: boolean;
+    sourceMap?: boolean;
 }
 
 declare interface RawSourceMap extends StartOfSourceMap {
@@ -95,24 +280,14 @@ declare interface RawSourceMap extends StartOfSourceMap {
     mappings: string;
 }
 
-export declare interface ScriptCompileOptions {
-    /**
-     * Production mode. Used to determine whether to generate hashed CSS variables
-     */
-    isProd?: boolean;
-    /**
-     * Enable/disable source map. Defaults to true.
-     */
-    sourceMap?: boolean;
-    /**
-     * https://babeljs.io/docs/en/babel-parser#plugins
-     */
-    babelParserPlugins?: ParserPlugin[];
-}
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
 
 export declare interface SFCBlock extends SFCCustomBlock {
     lang?: string;
-    src?: string;
     scoped?: boolean;
     module?: string | boolean;
 }
@@ -125,6 +300,7 @@ export declare interface SFCCustomBlock {
     };
     start: number;
     end: number;
+    src?: string;
     map?: RawSourceMap;
 }
 
@@ -148,7 +324,7 @@ export declare interface SFCDescriptor {
     shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
 }
 
-declare interface SFCScriptBlock extends SFCBlock {
+export declare interface SFCScriptBlock extends SFCBlock {
     type: 'script';
     setup?: string | boolean;
     bindings?: BindingMetadata;
@@ -163,12 +339,22 @@ declare interface SFCScriptBlock extends SFCBlock {
     scriptSetupAst?: any[];
 }
 
-declare interface StartOfSourceMap {
-    file?: string;
-    sourceRoot?: string;
+export declare interface SFCScriptCompileOptions {
+    /**
+     * Production mode. Used to determine whether to generate hashed CSS variables
+     */
+    isProd?: boolean;
+    /**
+     * Enable/disable source map. Defaults to true.
+     */
+    sourceMap?: boolean;
+    /**
+     * https://babeljs.io/docs/en/babel-parser#plugins
+     */
+    babelParserPlugins?: ParserPlugin[];
 }
 
-export declare interface StyleCompileOptions {
+export declare interface SFCStyleCompileOptions {
     source: string;
     filename: string;
     id: string;
@@ -181,18 +367,18 @@ export declare interface StyleCompileOptions {
     postcssPlugins?: any[];
 }
 
-export declare interface StyleCompileResults {
+export declare interface SFCStyleCompileResults {
     code: string;
     map: any | void;
     rawResult: LazyResult | void;
     errors: string[];
 }
 
-export declare interface TemplateCompileOptions {
+export declare interface SFCTemplateCompileOptions {
     source: string;
     filename: string;
-    compiler?: VueTemplateCompiler;
-    compilerOptions?: VueTemplateCompilerOptions;
+    compiler?: TemplateCompiler;
+    compilerOptions?: CompilerOptions;
     transformAssetUrls?: AssetURLOptions | boolean;
     transformAssetUrlsOptions?: TransformAssetUrlsOptions;
     preprocessLang?: string;
@@ -203,9 +389,10 @@ export declare interface TemplateCompileOptions {
     optimizeSSR?: boolean;
     prettify?: boolean;
     isTS?: boolean;
+    bindings?: BindingMetadata;
 }
 
-export declare interface TemplateCompileResult {
+export declare interface SFCTemplateCompileResults {
     ast: Object | undefined;
     code: string;
     source: string;
@@ -213,27 +400,27 @@ export declare interface TemplateCompileResult {
     errors: (string | WarningMessage)[];
 }
 
+declare interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export declare interface TemplateCompiler {
+    parseComponent(source: string, options?: any): SFCDescriptor;
+    compile(template: string, options: CompilerOptions): CompiledResult;
+    ssrCompile(template: string, options: CompilerOptions): CompiledResult;
+}
+
 declare interface TransformAssetUrlsOptions {
     /**
      * If base is provided, instead of transforming relative asset urls into
      * imports, they will be directly rewritten to absolute urls.
      */
     base?: string;
-}
-
-declare interface VueTemplateCompiler {
-    parseComponent(source: string, options?: any): SFCDescriptor;
-    compile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults;
-    ssrCompile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults;
-}
-
-declare interface VueTemplateCompilerOptions {
-    modules?: Object[];
-    outputSourceRange?: boolean;
-    whitespace?: 'preserve' | 'condense';
-    directives?: {
-        [key: string]: Function;
-    };
+    /**
+     * If true, also processes absolute urls.
+     */
+    includeAbsolute?: boolean;
 }
 
 declare interface VueTemplateCompilerParseOptions {
@@ -242,15 +429,7 @@ declare interface VueTemplateCompilerParseOptions {
     outputSourceRange?: boolean;
 }
 
-declare interface VueTemplateCompilerResults {
-    ast: Object | undefined;
-    render: string;
-    staticRenderFns: string[];
-    errors: (string | WarningMessage)[];
-    tips: (string | WarningMessage)[];
-}
-
-declare type WarningMessage = {
+export declare type WarningMessage = {
     msg: string;
     start?: number;
     end?: number;

package/dist/compiler-sfc.js

@@ -690,6 +690,9 @@ function parseComponent(source, options = {}) {
                     return cumulated;
                 }, {})
             };
+            if (typeof currentBlock.attrs.src === 'string') {
+                currentBlock.src = currentBlock.attrs.src;
+            }
             if (isSpecialTag(tag)) {
                 checkAttrs(currentBlock, attrs);
                 if (tag === 'script') {
@@ -730,9 +733,6 @@ function parseComponent(source, options = {}) {
             if (attr.name === 'module') {
                 block.module = attr.value || true;
             }
-            if (attr.name === 'src') {
-                block.src = attr.value;
-            }
         }
     }
     function end(tag, start) {
@@ -5789,7 +5789,7 @@ function resolveAsset(options, type, id, warnMissing) {
     // fallback to prototype chain
     const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn$3('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$3('Failed to resolve ' + type.slice(0, -1) + ': ' + id);
     }
     return res;
 }
@@ -8053,7 +8053,6 @@ function compileScript(sfc, options = {}) {
     let emitsTypeDecl;
     let emitsTypeDeclRaw;
     let emitIdentifier;
-    let hasAwait = false;
     // props/emits declared via types
     const typeDeclaredProps = {};
     const typeDeclaredEmits = new Set();
@@ -8233,33 +8232,6 @@ function compileScript(sfc, options = {}) {
             }
         });
     }
-    /**
-     * await foo()
-     * -->
-     * ;(
-     *   ([__temp,__restore] = withAsyncContext(() => foo())),
-     *   await __temp,
-     *   __restore()
-     * )
-     *
-     * const a = await foo()
-     * -->
-     * const a = (
-     *   ([__temp, __restore] = withAsyncContext(() => foo())),
-     *   __temp = await __temp,
-     *   __restore(),
-     *   __temp
-     * )
-     */
-    function processAwait(node, needSemi, isStatement) {
-        const argumentStart = node.argument.extra && node.argument.extra.parenthesized
-            ? node.argument.extra.parenStart
-            : node.argument.start;
-        const argumentStr = source.slice(argumentStart + startOffset, node.argument.end + startOffset);
-        const containsNestedAwait = /\bawait\b/.test(argumentStr);
-        s.overwrite(node.start + startOffset, argumentStart + startOffset, `${needSemi ? `;` : ``}(\n  ([__temp,__restore] = ${helper(`withAsyncContext`)}(${containsNestedAwait ? `async ` : ``}() => `);
-        s.appendLeft(node.end + startOffset, `)),\n  ${isStatement ? `` : `__temp = `}await __temp,\n  __restore()${isStatement ? `` : `,\n  __temp`}\n)`);
-    }
     /**
      * check defaults. If the default object is an object literal with only
      * static properties, we can directly generate more optimized default
@@ -8614,18 +8586,7 @@ function compileScript(sfc, options = {}) {
                         scope.push(child.body);
                     }
                     if (child.type === 'AwaitExpression') {
-                        hasAwait = true;
-                        // if the await expression is an expression statement and
-                        // - is in the root scope
-                        // - or is not the first statement in a nested block scope
-                        // then it needs a semicolon before the generated code.
-                        const currentScope = scope[scope.length - 1];
-                        const needsSemi = currentScope.some((n, i) => {
-                            return ((scope.length === 1 || i > 0) &&
-                                n.type === 'ExpressionStatement' &&
-                                n.start === child.start);
-                        });
-                        processAwait(child, needsSemi, parent.type === 'ExpressionStatement');
+                        error(`Vue 2 does not support top level await in <script setup>.`, child);
                     }
                 },
                 exit(node) {
@@ -8767,12 +8728,7 @@ function compileScript(sfc, options = {}) {
     if (propsIdentifier) {
         s.prependLeft(startOffset, `\nconst ${propsIdentifier} = __props${propsTypeDecl ? ` as ${genSetupPropsType(propsTypeDecl)}` : ``}\n`);
     }
-    // inject temp variables for async context preservation
-    if (hasAwait) {
-        const any = isTS ? `: any` : ``;
-        s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`);
-    }
-    const destructureElements = [`expose`];
+    const destructureElements = hasDefineExposeCall ? [`expose`] : [];
     if (emitIdentifier) {
         destructureElements.push(emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`);
     }
@@ -8789,7 +8745,9 @@ function compileScript(sfc, options = {}) {
             allBindings[key] = true;
         }
     }
-    const returned = `{ ${Object.keys(allBindings).join(', ')} }`;
+    // __sfc marker indicates these bindings are compiled from <script setup>
+    // and should not be proxied on `this`
+    const returned = `{ ${`__sfc: true,`}${Object.keys(allBindings).join(', ')} }`;
     s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`);
     // 11. finalize default export
     let runtimeOptions = ``;
@@ -8816,9 +8774,6 @@ function compileScript(sfc, options = {}) {
     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 ? `` : `  expose();\n`;
     // wrap setup code with function.
     if (isTS) {
         // for TS, make sure the exported type is still valid type with
@@ -8827,7 +8782,7 @@ function compileScript(sfc, options = {}) {
         // user's TS setting should compile it down to proper targets
         // export default defineComponent({ ...__default__, ... })
         const def = defaultExport ? `\n  ...${DEFAULT_VAR},` : ``;
-        s.prependLeft(startOffset, `\nexport default /*#__PURE__*/${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+        s.prependLeft(startOffset, `\nexport default /*#__PURE__*/${helper(`defineComponent`)}({${def}${runtimeOptions}\n  setup(${args}) {\n`);
         s.appendRight(endOffset, `})`);
     }
     else {
@@ -8835,12 +8790,11 @@ function compileScript(sfc, options = {}) {
             // without TS, can't rely on rest spread, so we use Object.assign
             // export default Object.assign(__default__, { ... })
             s.prependLeft(startOffset, `\nexport default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n  ` +
-                `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+                `setup(${args}) {\n`);
             s.appendRight(endOffset, `})`);
         }
         else {
-            s.prependLeft(startOffset, `\nexport default {${runtimeOptions}\n  ` +
-                `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+            s.prependLeft(startOffset, `\nexport default {${runtimeOptions}\n  setup(${args}) {\n`);
             s.appendRight(endOffset, `}`);
         }
     }
@@ -9378,7 +9332,7 @@ const cache = new lruCache(100);
 const splitRE = /\r?\n/g;
 const emptyRE = /^(?:\/\/)?\s*$/;
 function parse(options) {
-    const { source, filename = DEFAULT_FILENAME, compiler, compilerParseOptions = { pad: false }, sourceRoot = '', needMap = true } = options;
+    const { source, filename = DEFAULT_FILENAME, compiler, compilerParseOptions = { pad: false }, sourceRoot = '', sourceMap = true } = options;
     const cacheKey = hashSum(filename + source + JSON.stringify(compilerParseOptions));
     let output = cache.get(cacheKey);
     if (output) {
@@ -9394,7 +9348,7 @@ function parse(options) {
     }
     output.filename = filename;
     output.shouldForceReload = prevImports => hmrShouldReload(prevImports, output);
-    if (needMap) {
+    if (sourceMap) {
         if (output.script && !output.script.src) {
             output.script.map = generateSourceMap(filename, source, output.script.content, sourceRoot, compilerParseOptions.pad);
         }
@@ -9445,6 +9399,9 @@ function urlToRequire(url, transformAssetUrlsOption = {}) {
         const secondChar = url.charAt(1);
         url = url.slice(secondChar === '/' ? 2 : 1);
     }
+    if (isExternalUrl(url) || isDataUrl(url) || firstChar === '#') {
+        return returnValue;
+    }
     const uriParts = parseUriParts(url);
     if (transformAssetUrlsOption.base) {
         // explicit base - directly rewrite the url into absolute url
@@ -9457,7 +9414,10 @@ function urlToRequire(url, transformAssetUrlsOption = {}) {
         }
         return returnValue;
     }
-    if (firstChar === '.' || firstChar === '~' || firstChar === '@') {
+    if (transformAssetUrlsOption.includeAbsolute ||
+        firstChar === '.' ||
+        firstChar === '~' ||
+        firstChar === '@') {
         if (!uriParts.hash) {
             return `require("${url}")`;
         }
@@ -9487,6 +9447,14 @@ function parseUriParts(urlString) {
         }
     }
     return returnValue;
+}
+const externalRE = /^(https?:)?\/\//;
+function isExternalUrl(url) {
+    return externalRE.test(url);
+}
+const dataUrlRE = /^\s*data:/i;
+function isDataUrl(url) {
+    return dataUrlRE.test(url);
 }
 
 // vue compiler module for transforming `<tag>:<attribute>` to `require`
@@ -11741,8 +11709,19 @@ function genElement(el, state) {
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
+            let tag;
+            // check if this is a component in <script setup>
+            const bindings = state.options.bindings;
+            if (bindings && bindings.__isScriptSetup !== false) {
+                tag =
+                    checkBindingType(bindings, el.tag) ||
+                        checkBindingType(bindings, camelize(el.tag)) ||
+                        checkBindingType(bindings, capitalize(camelize(el.tag)));
+            }
+            if (!tag)
+                tag = `'${el.tag}'`;
             const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            code = `_c(${tag}${data ? `,${data}` : '' // data
             }${children ? `,${children}` : '' // children
             })`;
         }
@@ -11753,6 +11732,12 @@ function genElement(el, state) {
         return code;
     }
 }
+function checkBindingType(bindings, key) {
+    const type = bindings[key];
+    if (type && type.startsWith('setup')) {
+        return key;
+    }
+}
 // hoist static sub-trees out
 function genStatic(el, state) {
     el.staticProcessed = true;
@@ -12907,7 +12892,7 @@ const doNotPrefix = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
  * The input is expected to be the render function code directly returned from
  * `compile()` calls, e.g. `with(this){return ...}`
  */
-function stripWith(source, fnName = '', isFunctional = false, isTS = false, babelOptions = {}) {
+function prefixIdentifiers(source, fnName = '', isFunctional = false, isTS = false, babelOptions = {}, bindings) {
     source = `function ${fnName}(${isFunctional ? `_c,_vm` : ``}){${source}\n}`;
     const s = new MagicString(source);
     const plugins = [
@@ -12915,21 +12900,36 @@ function stripWith(source, fnName = '', isFunctional = false, isTS = false, babe
         ...((babelOptions === null || babelOptions === void 0 ? void 0 : babelOptions.plugins) || [])
     ];
     const ast = parser$1.parseExpression(source, Object.assign(Object.assign({}, babelOptions), { plugins }));
+    const isScriptSetup = bindings && bindings.__isScriptSetup !== false;
     walkIdentifiers(ast, ident => {
-        if (doNotPrefix(ident.name)) {
+        const { name } = ident;
+        if (doNotPrefix(name)) {
+            return;
+        }
+        if (!isScriptSetup) {
+            s.prependRight(ident.start, '_vm.');
             return;
         }
-        s.prependRight(ident.start, '_vm.');
+        s.overwrite(ident.start, ident.end, rewriteIdentifier(name, bindings));
     }, node => {
         if (node.type === 'WithStatement') {
             s.remove(node.start, node.body.start + 1);
             s.remove(node.end - 1, node.end);
             if (!isFunctional) {
-                s.prependRight(node.start, `var _vm=this;var _c=_vm._self._c;`);
+                s.prependRight(node.start, `var _vm=this,_c=_vm._self._c${isScriptSetup ? `,_setup=_vm._self._setupProxy;` : `;`}`);
             }
         }
     });
     return s.toString();
+}
+function rewriteIdentifier(name, bindings) {
+    const type = bindings[name];
+    if (type && type.startsWith('setup')) {
+        return `_setup.${name}`;
+    }
+    else {
+        return `_vm.${name}`;
+    }
 }
 
 function compileTemplate(options) {
@@ -12977,7 +12977,7 @@ function preprocess$1(options, preprocessor) {
     return res;
 }
 function actuallyCompile(options) {
-    const { source, compiler = _compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, transformAssetUrlsOptions, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true, isTS = false } = options;
+    const { source, compiler = _compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, transformAssetUrlsOptions, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true, isTS = false, bindings } = options;
     const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile;
     let finalCompilerOptions = compilerOptions;
     if (transformAssetUrls) {
@@ -12992,6 +12992,7 @@ function actuallyCompile(options) {
             filename: options.filename
         });
     }
+    finalCompilerOptions.bindings = bindings;
     const { ast, render, staticRenderFns, tips, errors } = compile(source, finalCompilerOptions);
     if (errors && errors.length) {
         return {
@@ -13005,8 +13006,8 @@ function actuallyCompile(options) {
     else {
         // transpile code with vue-template-es2015-compiler, which is a forked
         // version of Buble that applies ES2015 transforms + stripping `with` usage
-        let code = `var __render__ = ${stripWith(render, `render`, isFunctional, isTS, transpileOptions)}\n` +
-            `var __staticRenderFns__ = [${staticRenderFns.map(code => stripWith(code, ``, isFunctional, isTS, transpileOptions))}]` +
+        let code = `var __render__ = ${prefixIdentifiers(render, `render`, isFunctional, isTS, transpileOptions, bindings)}\n` +
+            `var __staticRenderFns__ = [${staticRenderFns.map(code => prefixIdentifiers(code, ``, isFunctional, isTS, transpileOptions, bindings))}]` +
             `\n`;
         // #23 we use __render__ to avoid `render` not being prefixed by the
         // transpiler when stripping with, but revert it back to `render` to
@@ -17608,9 +17609,98 @@ function preprocess(options, preprocessor) {
     }, options.preprocessOptions));
 }
 
+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$]+)/;
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+function rewriteDefault(input, as, parserPlugins) {
+    if (!hasDefaultExport(input)) {
+        return input + `\nconst ${as} = {}`;
+    }
+    let replaced;
+    const classMatch = input.match(exportDefaultClassRE);
+    if (classMatch) {
+        replaced =
+            input.replace(exportDefaultClassRE, '$1class $2') +
+                `\nconst ${as} = ${classMatch[2]}`;
+    }
+    else {
+        replaced = input.replace(defaultExportRE, `$1const ${as} =`);
+    }
+    if (!hasDefaultExport(replaced)) {
+        return replaced;
+    }
+    // if the script somehow still contains `default export`, it probably has
+    // multi-line comments or template strings. fallback to a full parse.
+    const s = new MagicString(input);
+    const ast = parser$1.parse(input, {
+        sourceType: 'module',
+        plugins: parserPlugins
+    }).program.body;
+    ast.forEach(node => {
+        if (node.type === 'ExportDefaultDeclaration') {
+            s.overwrite(node.start, node.declaration.start, `const ${as} = `);
+        }
+        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 end = specifierEnd(input, specifier.local.end, node.end);
+                            s.prepend(`import { default as __VUE_DEFAULT__ } from '${node.source.value}'\n`);
+                            s.overwrite(specifier.start, end, ``);
+                            s.append(`\nconst ${as} = __VUE_DEFAULT__`);
+                            continue;
+                        }
+                        else {
+                            const end = specifierEnd(input, specifier.exported.end, node.end);
+                            s.prepend(`import { ${input.slice(specifier.local.start, specifier.local.end)} } from '${node.source.value}'\n`);
+                            s.overwrite(specifier.start, end, ``);
+                            s.append(`\nconst ${as} = ${specifier.local.name}`);
+                            continue;
+                        }
+                    }
+                    const end = specifierEnd(input, specifier.end, node.end);
+                    s.overwrite(specifier.start, end, ``);
+                    s.append(`\nconst ${as} = ${specifier.local.name}`);
+                }
+            }
+        }
+    });
+    return s.toString();
+}
+function hasDefaultExport(input) {
+    return defaultExportRE.test(input) || namedDefaultExportRE.test(input);
+}
+function specifierEnd(input, end, nodeEnd) {
+    // export { default   , foo } ...
+    let hasCommas = false;
+    let oldEnd = end;
+    while (end < nodeEnd) {
+        if (/\s/.test(input.charAt(end))) {
+            end++;
+        }
+        else if (input.charAt(end) === ',') {
+            end++;
+            hasCommas = true;
+            break;
+        }
+        else if (input.charAt(end) === '}') {
+            break;
+        }
+    }
+    return hasCommas ? end : oldEnd;
+}
+
 exports.compileScript = compileScript;
 exports.compileStyle = compileStyle;
 exports.compileStyleAsync = compileStyleAsync;
 exports.compileTemplate = compileTemplate;
 exports.generateCodeFrame = generateCodeFrame;
 exports.parse = parse;
+exports.rewriteDefault = rewriteDefault;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-beta.2",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",