@vue/compiler-sfc 2.7.0-beta.2 → 2.7.0-beta.3

package/dist/compiler-sfc.d.ts

@@ -261,16 +261,7 @@ declare type ModuleOptions = {
     staticKeys?: Array<string>;
 };
 
-export declare function parse(options: ParseOptions): SFCDescriptor;
-
-declare interface ParseOptions {
-    source: string;
-    filename?: string;
-    compiler?: TemplateCompiler;
-    compilerParseOptions?: VueTemplateCompilerParseOptions;
-    sourceRoot?: string;
-    sourceMap?: boolean;
-}
+export declare function parse(options: SFCParseOptions): SFCDescriptor;
 
 declare interface RawSourceMap extends StartOfSourceMap {
     version: string;
@@ -312,7 +303,8 @@ export declare interface SFCDescriptor {
     scriptSetup: SFCScriptBlock | null;
     styles: SFCBlock[];
     customBlocks: SFCCustomBlock[];
-    errors: WarningMessage[];
+    cssVars: string[];
+    errors: (string | WarningMessage)[];
     /**
      * compare with an existing descriptor to determine whether HMR should perform
      * a reload vs. re-render.
@@ -324,6 +316,19 @@ export declare interface SFCDescriptor {
     shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
 }
 
+export declare interface SFCParseOptions {
+    source: string;
+    filename?: string;
+    compiler?: TemplateCompiler;
+    compilerParseOptions?: VueTemplateCompilerParseOptions;
+    sourceRoot?: string;
+    sourceMap?: boolean;
+    /**
+     * @deprecated use `sourceMap` instead.
+     */
+    needMap?: boolean;
+}
+
 export declare interface SFCScriptBlock extends SFCBlock {
     type: 'script';
     setup?: string | boolean;
@@ -340,6 +345,11 @@ export declare interface SFCScriptBlock extends SFCBlock {
 }
 
 export declare interface SFCScriptCompileOptions {
+    /**
+     * Scope ID for prefixing injected CSS variables.
+     * This must be consistent with the `id` passed to `compileStyle`.
+     */
+    id: string;
     /**
      * Production mode. Used to determine whether to generate hashed CSS variables
      */
@@ -365,6 +375,7 @@ export declare interface SFCStyleCompileOptions {
     preprocessOptions?: any;
     postcssOptions?: any;
     postcssPlugins?: any[];
+    isProd?: boolean;
 }
 
 export declare interface SFCStyleCompileResults {

package/dist/compiler-sfc.js

@@ -658,6 +658,7 @@ function parseComponent(source, options = {}) {
         scriptSetup: null,
         styles: [],
         customBlocks: [],
+        cssVars: [],
         errors: [],
         shouldForceReload: null // attached in parse() by compiler-sfc
     };
@@ -7959,6 +7960,268 @@ function warn(msg) {
     console.warn(`\x1b[1m\x1b[33m[@vue/compiler-sfc]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`);
 }
 
+const doNotPrefix = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
+    'require,' + // for webpack
+    'arguments,' + // parsed as identifier but is a special keyword...
+    '_c' // cached to save property access
+);
+/**
+ * The input is expected to be a valid expression.
+ */
+function prefixIdentifiers(source, isFunctional = false, isTS = false, babelOptions = {}, bindings) {
+    const s = new MagicString(source);
+    const plugins = [
+        ...(isTS ? ['typescript'] : []),
+        ...((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 => {
+        const { name } = ident;
+        if (doNotPrefix(name)) {
+            return;
+        }
+        if (!isScriptSetup) {
+            s.prependRight(ident.start, '_vm.');
+            return;
+        }
+        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,_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}`;
+    }
+}
+
+const CSS_VARS_HELPER = `useCssVars`;
+function genCssVarsFromList(vars, id, isProd, isSSR = false) {
+    return `{\n  ${vars
+        .map(key => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`)
+        .join(',\n  ')}\n}`;
+}
+function genVarName(id, raw, isProd) {
+    if (isProd) {
+        return hashSum(id + raw);
+    }
+    else {
+        return `${id}-${raw.replace(/([^\w-])/g, '_')}`;
+    }
+}
+function normalizeExpression(exp) {
+    exp = exp.trim();
+    if ((exp[0] === `'` && exp[exp.length - 1] === `'`) ||
+        (exp[0] === `"` && exp[exp.length - 1] === `"`)) {
+        return exp.slice(1, -1);
+    }
+    return exp;
+}
+const vBindRE = /v-bind\s*\(/g;
+function parseCssVars(sfc) {
+    const vars = [];
+    sfc.styles.forEach(style => {
+        let match;
+        // ignore v-bind() in comments /* ... */
+        const content = style.content.replace(/\/\*([\s\S]*?)\*\//g, '');
+        while ((match = vBindRE.exec(content))) {
+            const start = match.index + match[0].length;
+            const end = lexBinding(content, start);
+            if (end !== null) {
+                const variable = normalizeExpression(content.slice(start, end));
+                if (!vars.includes(variable)) {
+                    vars.push(variable);
+                }
+            }
+        }
+    });
+    return vars;
+}
+function lexBinding(content, start) {
+    let state = 0 /* LexerState.inParens */;
+    let parenDepth = 0;
+    for (let i = start; i < content.length; i++) {
+        const char = content.charAt(i);
+        switch (state) {
+            case 0 /* LexerState.inParens */:
+                if (char === `'`) {
+                    state = 1 /* LexerState.inSingleQuoteString */;
+                }
+                else if (char === `"`) {
+                    state = 2 /* LexerState.inDoubleQuoteString */;
+                }
+                else if (char === `(`) {
+                    parenDepth++;
+                }
+                else if (char === `)`) {
+                    if (parenDepth > 0) {
+                        parenDepth--;
+                    }
+                    else {
+                        return i;
+                    }
+                }
+                break;
+            case 1 /* LexerState.inSingleQuoteString */:
+                if (char === `'`) {
+                    state = 0 /* LexerState.inParens */;
+                }
+                break;
+            case 2 /* LexerState.inDoubleQuoteString */:
+                if (char === `"`) {
+                    state = 0 /* LexerState.inParens */;
+                }
+                break;
+        }
+    }
+    return null;
+}
+const cssVarsPlugin = opts => {
+    const { id, isProd } = opts;
+    return {
+        postcssPlugin: 'vue-sfc-vars',
+        Declaration(decl) {
+            // rewrite CSS variables
+            const value = decl.value;
+            if (vBindRE.test(value)) {
+                vBindRE.lastIndex = 0;
+                let transformed = '';
+                let lastIndex = 0;
+                let match;
+                while ((match = vBindRE.exec(value))) {
+                    const start = match.index + match[0].length;
+                    const end = lexBinding(value, start);
+                    if (end !== null) {
+                        const variable = normalizeExpression(value.slice(start, end));
+                        transformed +=
+                            value.slice(lastIndex, match.index) +
+                                `var(--${genVarName(id, variable, isProd)})`;
+                        lastIndex = end + 1;
+                    }
+                }
+                decl.value = transformed + value.slice(lastIndex);
+            }
+        }
+    };
+};
+cssVarsPlugin.postcss = true;
+function genCssVarsCode(vars, bindings, id, isProd) {
+    const varsExp = genCssVarsFromList(vars, id, isProd);
+    return `_${CSS_VARS_HELPER}((_vm, _setup) => ${prefixIdentifiers(`(${varsExp})`, false, false, undefined, bindings)})`;
+}
+// <script setup> already gets the calls injected as part of the transform
+// this is only for single normal <script>
+function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd) {
+    return (`\nimport { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'\n` +
+        `const __injectCSSVars__ = () => {\n${genCssVarsCode(cssVars, bindings, id, isProd)}}\n` +
+        `const __setup__ = __default__.setup\n` +
+        `__default__.setup = __setup__\n` +
+        `  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }\n` +
+        `  : __injectCSSVars__\n`);
+}
+
+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;
+}
+
 // Special compiler macros
 const DEFINE_PROPS = 'defineProps';
 const DEFINE_EMITS = 'defineEmits';
@@ -7972,11 +8235,12 @@ const isBuiltInDir$1 = makeMap(`once,memo,if,for,else,else-if,slot,text,html,on,
  * 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 = {}) {
+function compileScript(sfc, options = { id: '' }) {
     let { filename, script, scriptSetup, source } = sfc;
     const isProd = !!options.isProd;
     const genSourceMap = options.sourceMap !== false;
-    // const cssVars = sfc.cssVars
+    const cssVars = sfc.cssVars;
+    const scopeId = options.id ? options.id.replace(/^data-v-/, '') : '';
     const scriptLang = script && script.lang;
     const scriptSetupLang = scriptSetup && scriptSetup.lang;
     const isTS = scriptLang === 'ts' ||
@@ -8013,6 +8277,11 @@ function compileScript(sfc, options = {}) {
                 sourceType: 'module'
             }).program;
             const bindings = analyzeScriptBindings(scriptAst.body);
+            if (cssVars.length) {
+                content = rewriteDefault(content, DEFAULT_VAR, plugins);
+                content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, isProd);
+                content += `\nexport default ${DEFAULT_VAR}`;
+            }
             return Object.assign(Object.assign({}, script), { content,
                 map,
                 bindings, scriptAst: scriptAst.body });
@@ -8713,7 +8982,10 @@ function compileScript(sfc, options = {}) {
         bindingMetadata[key] = setupBindings[key];
     }
     // 8. inject `useCssVars` calls
-    // Not backported in Vue 2
+    if (cssVars.length) {
+        helperImports.add(CSS_VARS_HELPER);
+        s.prependRight(startOffset, `\n${genCssVarsCode(cssVars, bindingMetadata, scopeId, isProd)}\n`);
+    }
     // 9. finalize setup() argument signature
     let args = `__props`;
     if (propsTypeDecl) {
@@ -9332,7 +9604,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 = '', sourceMap = true } = options;
+    const { source, filename = DEFAULT_FILENAME, compiler, compilerParseOptions = { pad: false }, sourceRoot = '', needMap = true, sourceMap = needMap } = options;
     const cacheKey = hashSum(filename + source + JSON.stringify(compilerParseOptions));
     let output = cache.get(cacheKey);
     if (output) {
@@ -9347,6 +9619,8 @@ function parse(options) {
         output = parseComponent(source, compilerParseOptions);
     }
     output.filename = filename;
+    // parse CSS vars
+    output.cssVars = parseCssVars(output);
     output.shouldForceReload = prevImports => hmrShouldReload(prevImports, output);
     if (sourceMap) {
         if (output.script && !output.script.src) {
@@ -12881,57 +13155,6 @@ var _compiler = /*#__PURE__*/Object.freeze({
 	generateCodeFrame: generateCodeFrame
 });
 
-const doNotPrefix = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require,' + // for webpack
-    'arguments,' + // parsed as identifier but is a special keyword...
-    '_c' // cached to save property access
-);
-/**
- * The input is expected to be the render function code directly returned from
- * `compile()` calls, e.g. `with(this){return ...}`
- */
-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 = [
-        ...(isTS ? ['typescript'] : []),
-        ...((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 => {
-        const { name } = ident;
-        if (doNotPrefix(name)) {
-            return;
-        }
-        if (!isScriptSetup) {
-            s.prependRight(ident.start, '_vm.');
-            return;
-        }
-        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,_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) {
     const { preprocessLang } = options;
     const preprocessor = preprocessLang && consolidate[preprocessLang];
@@ -13006,8 +13229,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__ = ${prefixIdentifiers(render, `render`, isFunctional, isTS, transpileOptions, bindings)}\n` +
-            `var __staticRenderFns__ = [${staticRenderFns.map(code => prefixIdentifiers(code, ``, isFunctional, isTS, transpileOptions, bindings))}]` +
+        let code = `var __render__ = ${prefixIdentifiers(`function render(${isFunctional ? `_c,_vm` : ``}){${render}\n}`, isFunctional, isTS, transpileOptions, bindings)}\n` +
+            `var __staticRenderFns__ = [${staticRenderFns.map(code => prefixIdentifiers(`function (${isFunctional ? `_c,_vm` : ``}){${code}\n}`, 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
@@ -17279,9 +17502,8 @@ function processRule(id, rule) {
         });
     }).processSync(rule.selector);
 }
-function rewriteSelector(id, selector, selectorRoot, slotted = false) {
+function rewriteSelector(id, selector, selectorRoot) {
     let node = null;
-    let shouldInject = true;
     // find the last child node to insert attribute selector
     selector.each(n => {
         // DEPRECATED ">>>" and "/deep/" combinator
@@ -17328,23 +17550,22 @@ function rewriteSelector(id, selector, selectorRoot, slotted = false) {
                 }
                 return false;
             }
-            // slot: use selector inside `::v-slotted` and inject [id + '-s']
-            // instead.
+            // !!! Vue 2 does not have :slotted support
             // ::v-slotted(.foo) -> .foo[xxxxxxx-s]
-            if (value === ':slotted' || value === '::v-slotted') {
-                rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */);
-                let last = n;
-                n.nodes[0].each(ss => {
-                    selector.insertAfter(last, ss);
-                    last = ss;
-                });
-                // selector.insertAfter(n, n.nodes[0])
-                selector.removeChild(n);
-                // since slotted attribute already scopes the selector there's no
-                // need for the non-slot attribute.
-                shouldInject = false;
-                return false;
-            }
+            // if (value === ':slotted' || value === '::v-slotted') {
+            //   rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */)
+            //   let last: selectorParser.Selector['nodes'][0] = n
+            //   n.nodes[0].each(ss => {
+            //     selector.insertAfter(last, ss)
+            //     last = ss
+            //   })
+            //   // selector.insertAfter(n, n.nodes[0])
+            //   selector.removeChild(n)
+            //   // since slotted attribute already scopes the selector there's no
+            //   // need for the non-slot attribute.
+            //   shouldInject = false
+            //   return false
+            // }
             // global: replace with inner selector and do not inject [id].
             // ::v-global(.foo) -> .foo
             if (value === ':global' || value === '::v-global') {
@@ -17366,14 +17587,13 @@ function rewriteSelector(id, selector, selectorRoot, slotted = false) {
         // So all leading spaces must be eliminated to avoid problems.
         selector.first.spaces.before = '';
     }
-    if (shouldInject) {
-        const idToAdd = slotted ? id + '-s' : id;
+    {
         selector.insertAfter(
         // If node is null it means we need to inject [id] at the start
         // insertAfter can handle `null` here
         node, selectorParser.attribute({
-            attribute: idToAdd,
-            value: idToAdd,
+            attribute: id,
+            value: id,
             raws: {},
             quoteMark: `"`
         }));
@@ -17546,12 +17766,13 @@ function compileStyleAsync(options) {
     return Promise.resolve(doCompileStyle(Object.assign(Object.assign({}, options), { isAsync: true })));
 }
 function doCompileStyle(options) {
-    const { filename, id, scoped = true, trim = true, preprocessLang, postcssOptions, postcssPlugins } = options;
+    const { filename, id, scoped = true, trim = true, isProd = false, preprocessLang, postcssOptions, postcssPlugins } = options;
     const preprocessor = preprocessLang && processors[preprocessLang];
     const preProcessedSource = preprocessor && preprocess(options, preprocessor);
     const map = preProcessedSource ? preProcessedSource.map : options.map;
     const source = preProcessedSource ? preProcessedSource.code : options.source;
     const plugins = (postcssPlugins || []).slice();
+    plugins.unshift(cssVarsPlugin({ id: id.replace(/^data-v-/, ''), isProd }));
     if (trim) {
         plugins.push(trimPlugin());
     }
@@ -17609,94 +17830,6 @@ 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;

package/package.json

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