switch to vuepress

22 files changed, 730 insertions, 0 deletions

diff --git a/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts b/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts
new file mode 100644
index 00000000..078f5444
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts
@@ -0,0 +1,25 @@
+import { LazyResult } from 'postcss';
+export interface StyleCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    map?: any;
+    scoped?: boolean;
+    trim?: boolean;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    postcssOptions?: any;
+    postcssPlugins?: any[];
+}
+export interface AsyncStyleCompileOptions extends StyleCompileOptions {
+    isAsync?: boolean;
+}
+export interface StyleCompileResults {
+    code: string;
+    map: any | void;
+    rawResult: LazyResult | void;
+    errors: string[];
+}
+export declare function compileStyle(options: StyleCompileOptions): StyleCompileResults;
+export declare function compileStyleAsync(options: StyleCompileOptions): Promise<StyleCompileResults>;
+export declare function doCompileStyle(options: AsyncStyleCompileOptions): StyleCompileResults;
diff --git a/node_modules/@vue/component-compiler-utils/dist/compileStyle.js b/node_modules/@vue/component-compiler-utils/dist/compileStyle.js
new file mode 100644
index 00000000..f637c490
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/compileStyle.js
@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = require('postcss');
+const trim_1 = require("./stylePlugins/trim");
+const scoped_1 = require("./stylePlugins/scoped");
+const styleProcessors_1 = require("./styleProcessors");
+function compileStyle(options) {
+    return doCompileStyle(Object.assign({}, options, { isAsync: false }));
+}
+exports.compileStyle = compileStyle;
+function compileStyleAsync(options) {
+    return Promise.resolve(doCompileStyle(Object.assign({}, options, { isAsync: true })));
+}
+exports.compileStyleAsync = compileStyleAsync;
+function doCompileStyle(options) {
+    const { filename, id, scoped = true, trim = true, preprocessLang, postcssOptions, postcssPlugins } = options;
+    const preprocessor = preprocessLang && styleProcessors_1.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();
+    if (trim) {
+        plugins.push(trim_1.default());
+    }
+    if (scoped) {
+        plugins.push(scoped_1.default(id));
+    }
+    const postCSSOptions = Object.assign({}, postcssOptions, { to: filename, from: filename });
+    if (map) {
+        postCSSOptions.map = {
+            inline: false,
+            annotation: false,
+            prev: map
+        };
+    }
+    let result, code, outMap;
+    const errors = [];
+    if (preProcessedSource && preProcessedSource.errors.length) {
+        errors.push(...preProcessedSource.errors);
+    }
+    try {
+        result = postcss(plugins).process(source, postCSSOptions);
+        // In async mode, return a promise.
+        if (options.isAsync) {
+            return result
+                .then((result) => ({
+                code: result.css || '',
+                map: result.map && result.map.toJSON(),
+                errors,
+                rawResult: result
+            }))
+                .catch((error) => ({
+                code: '',
+                map: undefined,
+                errors: [...errors, error.message],
+                rawResult: undefined
+            }));
+        }
+        // force synchronous transform (we know we only have sync plugins)
+        code = result.css;
+        outMap = result.map;
+    }
+    catch (e) {
+        errors.push(e);
+    }
+    return {
+        code: code || ``,
+        map: outMap && outMap.toJSON(),
+        errors,
+        rawResult: result
+    };
+}
+exports.doCompileStyle = doCompileStyle;
+function preprocess(options, preprocessor) {
+    return preprocessor.render(options.source, options.map, Object.assign({
+        filename: options.filename
+    }, options.preprocessOptions));
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts
new file mode 100644
index 00000000..8fa376ee
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts
@@ -0,0 +1,22 @@
+import { VueTemplateCompiler, VueTemplateCompilerOptions } from './types';
+import { AssetURLOptions } from './templateCompilerModules/assetUrl';
+export interface TemplateCompileOptions {
+    source: string;
+    filename: string;
+    compiler: VueTemplateCompiler;
+    compilerOptions?: VueTemplateCompilerOptions;
+    transformAssetUrls?: AssetURLOptions | boolean;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    transpileOptions?: any;
+    isProduction?: boolean;
+    isFunctional?: boolean;
+    optimizeSSR?: boolean;
+}
+export interface TemplateCompileResult {
+    code: string;
+    source: string;
+    tips: string[];
+    errors: string[];
+}
+export declare function compileTemplate(options: TemplateCompileOptions): TemplateCompileResult;
diff --git a/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js
new file mode 100644
index 00000000..b958eb85
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js
@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assetUrl_1 = require("./templateCompilerModules/assetUrl");
+const srcset_1 = require("./templateCompilerModules/srcset");
+const prettier = require('prettier');
+const consolidate = require('consolidate');
+const transpile = require('vue-template-es2015-compiler');
+function compileTemplate(options) {
+    const { preprocessLang } = options;
+    const preprocessor = preprocessLang && consolidate[preprocessLang];
+    if (preprocessor) {
+        return actuallyCompile(Object.assign({}, options, {
+            source: preprocess(options, preprocessor)
+        }));
+    }
+    else if (preprocessLang) {
+        return {
+            code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+            source: options.source,
+            tips: [
+                `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.`
+            ],
+            errors: [
+                `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.`
+            ]
+        };
+    }
+    else {
+        return actuallyCompile(options);
+    }
+}
+exports.compileTemplate = compileTemplate;
+function preprocess(options, preprocessor) {
+    const { source, filename, preprocessOptions } = options;
+    const finalPreprocessOptions = Object.assign({
+        filename
+    }, preprocessOptions);
+    // Consolidate exposes a callback based API, but the callback is in fact
+    // called synchronously for most templating engines. In our case, we have to
+    // expose a synchronous API so that it is usable in Jest transforms (which
+    // have to be sync because they are applied via Node.js require hooks)
+    let res, err;
+    preprocessor.render(source, finalPreprocessOptions, (_err, _res) => {
+        if (_err)
+            err = _err;
+        res = _res;
+    });
+    if (err)
+        throw err;
+    return res;
+}
+function actuallyCompile(options) {
+    const { source, compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false } = options;
+    const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile;
+    let finalCompilerOptions = compilerOptions;
+    if (transformAssetUrls) {
+        const builtInModules = [
+            transformAssetUrls === true
+                ? assetUrl_1.default()
+                : assetUrl_1.default(transformAssetUrls),
+            srcset_1.default()
+        ];
+        finalCompilerOptions = Object.assign({}, compilerOptions, {
+            modules: [...builtInModules, ...(compilerOptions.modules || [])]
+        });
+    }
+    const { render, staticRenderFns, tips, errors } = compile(source, finalCompilerOptions);
+    if (errors && errors.length) {
+        return {
+            code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+            source,
+            tips,
+            errors
+        };
+    }
+    else {
+        const finalTranspileOptions = Object.assign({}, transpileOptions, {
+            transforms: Object.assign({}, transpileOptions.transforms, {
+                stripWithFunctional: isFunctional
+            })
+        });
+        const toFunction = (code) => {
+            return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`;
+        };
+        // transpile code with vue-template-es2015-compiler, which is a forked
+        // version of Buble that applies ES2015 transforms + stripping `with` usage
+        let code = transpile(`var __render__ = ${toFunction(render)}\n` +
+            `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`, finalTranspileOptions) + `\n`;
+        // #23 we use __render__ to avoid `render` not being prefixed by the
+        // transpiler when stripping with, but revert it back to `render` to
+        // maintain backwards compat
+        code = code.replace(/\s__(render|staticRenderFns)__\s/g, ' $1 ');
+        if (!isProduction) {
+            // mark with stripped (this enables Vue to use correct runtime proxy
+            // detection)
+            code += `render._withStripped = true`;
+            code = prettier.format(code, { semi: false, parser: 'babylon' });
+        }
+        return {
+            code,
+            source,
+            tips,
+            errors
+        };
+    }
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/index.d.ts b/node_modules/@vue/component-compiler-utils/dist/index.d.ts
new file mode 100644
index 00000000..f7e9cf3e
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/index.d.ts
@@ -0,0 +1,5 @@
+import { parse, SFCBlock, SFCCustomBlock, SFCDescriptor } from './parse';
+import { compileTemplate, TemplateCompileOptions, TemplateCompileResult } from './compileTemplate';
+import { compileStyle, compileStyleAsync, StyleCompileOptions, StyleCompileResults } from './compileStyle';
+export { parse, compileTemplate, compileStyle, compileStyleAsync };
+export { SFCBlock, SFCCustomBlock, SFCDescriptor, TemplateCompileOptions, TemplateCompileResult, StyleCompileOptions, StyleCompileResults };
diff --git a/node_modules/@vue/component-compiler-utils/dist/index.js b/node_modules/@vue/component-compiler-utils/dist/index.js
new file mode 100644
index 00000000..a8f40555
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/index.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_1 = require("./parse");
+exports.parse = parse_1.parse;
+const compileTemplate_1 = require("./compileTemplate");
+exports.compileTemplate = compileTemplate_1.compileTemplate;
+const compileStyle_1 = require("./compileStyle");
+exports.compileStyle = compileStyle_1.compileStyle;
+exports.compileStyleAsync = compileStyle_1.compileStyleAsync;
diff --git a/node_modules/@vue/component-compiler-utils/dist/parse.d.ts b/node_modules/@vue/component-compiler-utils/dist/parse.d.ts
new file mode 100644
index 00000000..f82493e7
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/parse.d.ts
@@ -0,0 +1,32 @@
+import { RawSourceMap, VueTemplateCompiler, VueTemplateCompilerParseOptions } from './types';
+export interface ParseOptions {
+    source: string;
+    filename?: string;
+    compiler: VueTemplateCompiler;
+    compilerParseOptions?: VueTemplateCompilerParseOptions;
+    sourceRoot?: string;
+    needMap?: boolean;
+}
+export interface SFCCustomBlock {
+    type: string;
+    content: string;
+    attrs: {
+        [key: string]: string | true;
+    };
+    start: number;
+    end: number;
+    map?: RawSourceMap;
+}
+export interface SFCBlock extends SFCCustomBlock {
+    lang?: string;
+    src?: string;
+    scoped?: boolean;
+    module?: string | boolean;
+}
+export interface SFCDescriptor {
+    template: SFCBlock | null;
+    script: SFCBlock | null;
+    styles: SFCBlock[];
+    customBlocks: SFCCustomBlock[];
+}
+export declare function parse(options: ParseOptions): SFCDescriptor;
diff --git a/node_modules/@vue/component-compiler-utils/dist/parse.js b/node_modules/@vue/component-compiler-utils/dist/parse.js
new file mode 100644
index 00000000..17c95ae1
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/parse.js
@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hash = require('hash-sum');
+const cache = require('lru-cache')(100);
+const { SourceMapGenerator } = require('source-map');
+const splitRE = /\r?\n/g;
+const emptyRE = /^(?:\/\/)?\s*$/;
+function parse(options) {
+    const { source, filename = '', compiler, compilerParseOptions = { pad: 'line' }, sourceRoot = process.cwd(), needMap = true } = options;
+    const cacheKey = hash(filename + source);
+    let output = cache.get(cacheKey);
+    if (output)
+        return output;
+    output = compiler.parseComponent(source, compilerParseOptions);
+    if (needMap) {
+        if (output.script && !output.script.src) {
+            output.script.map = generateSourceMap(filename, source, output.script.content, sourceRoot);
+        }
+        if (output.styles) {
+            output.styles.forEach(style => {
+                if (!style.src) {
+                    style.map = generateSourceMap(filename, source, style.content, sourceRoot);
+                }
+            });
+        }
+    }
+    cache.set(cacheKey, output);
+    return output;
+}
+exports.parse = parse;
+function generateSourceMap(filename, source, generated, sourceRoot) {
+    const map = new SourceMapGenerator({
+        file: filename,
+        sourceRoot
+    });
+    map.setSourceContent(filename, source);
+    generated.split(splitRE).forEach((line, index) => {
+        if (!emptyRE.test(line)) {
+            map.addMapping({
+                source: filename,
+                original: {
+                    line: index + 1,
+                    column: 0
+                },
+                generated: {
+                    line: index + 1,
+                    column: 0
+                }
+            });
+        }
+    });
+    return map.toJSON();
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts
new file mode 100644
index 00000000..20c0dd03
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts
@@ -0,0 +1,3 @@
+import * as postcss from 'postcss';
+declare const _default: postcss.Plugin<any>;
+export default _default;
diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js
new file mode 100644
index 00000000..e2dbd1a9
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js
@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = require("postcss");
+// postcss-selector-parser does have typings but it's problematic to work with.
+const selectorParser = require('postcss-selector-parser');
+exports.default = postcss.plugin('add-id', (options) => (root) => {
+    const id = options;
+    const keyframes = Object.create(null);
+    root.each(function rewriteSelector(node) {
+        if (!node.selector) {
+            // handle media queries
+            if (node.type === 'atrule') {
+                if (node.name === 'media' || node.name === 'supports') {
+                    node.each(rewriteSelector);
+                }
+                else if (/-?keyframes$/.test(node.name)) {
+                    // register keyframes
+                    keyframes[node.params] = node.params = node.params + '-' + id;
+                }
+            }
+            return;
+        }
+        node.selector = selectorParser((selectors) => {
+            selectors.each((selector) => {
+                let node = null;
+                selector.each((n) => {
+                    // ">>>" combinator
+                    if (n.type === 'combinator' && n.value === '>>>') {
+                        n.value = ' ';
+                        n.spaces.before = n.spaces.after = '';
+                        return false;
+                    }
+                    // /deep/ alias for >>>, since >>> doesn't work in SASS
+                    if (n.type === 'tag' && n.value === '/deep/') {
+                        const prev = n.prev();
+                        if (prev && prev.type === 'combinator' && prev.value === ' ') {
+                            prev.remove();
+                        }
+                        n.remove();
+                        return false;
+                    }
+                    if (n.type !== 'pseudo' && n.type !== 'combinator') {
+                        node = n;
+                    }
+                });
+                if (node) {
+                    node.spaces.after = '';
+                }
+                else {
+                    // For deep selectors & standalone pseudo selectors,
+                    // the attribute selectors are prepended rather than appended.
+                    // So all leading spaces must be eliminated to avoid problems.
+                    selector.first.spaces.before = '';
+                }
+                selector.insertAfter(node, selectorParser.attribute({
+                    attribute: id
+                }));
+            });
+        }).processSync(node.selector);
+    });
+    // If keyframes are found in this <style>, find and rewrite animation names
+    // in declarations.
+    // Caveat: this only works for keyframes and animation rules in the same
+    // <style> element.
+    if (Object.keys(keyframes).length) {
+        root.walkDecls(decl => {
+            // individual animation-name declaration
+            if (/^(-\w+-)?animation-name$/.test(decl.prop)) {
+                decl.value = decl.value
+                    .split(',')
+                    .map(v => keyframes[v.trim()] || v.trim())
+                    .join(',');
+            }
+            // shorthand
+            if (/^(-\w+-)?animation$/.test(decl.prop)) {
+                decl.value = decl.value
+                    .split(',')
+                    .map(v => {
+                    const vals = v.trim().split(/\s+/);
+                    const i = vals.findIndex(val => keyframes[val]);
+                    if (i !== -1) {
+                        vals.splice(i, 1, keyframes[vals[i]]);
+                        return vals.join(' ');
+                    }
+                    else {
+                        return v;
+                    }
+                })
+                    .join(',');
+            }
+        });
+    }
+});
diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts
new file mode 100644
index 00000000..ec36581c
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts
@@ -0,0 +1,3 @@
+import * as postcss from 'postcss';
+declare const _default: postcss.Plugin<{}>;
+export default _default;
diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js
new file mode 100644
index 00000000..6895ce2f
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = require("postcss");
+exports.default = postcss.plugin('trim', () => (css) => {
+    css.walk(({ type, raws }) => {
+        if (type === 'rule' || type === 'atrule') {
+            raws.before = raws.after = '\n';
+        }
+    });
+});
diff --git a/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts
new file mode 100644
index 00000000..cc324a8c
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts
@@ -0,0 +1,11 @@
+export interface StylePreprocessor {
+    render(source: string, map: any | null, options: any): StylePreprocessorResults;
+}
+export interface StylePreprocessorResults {
+    code: string;
+    map?: any;
+    errors: Array<Error>;
+}
+export declare const processors: {
+    [key: string]: StylePreprocessor;
+};
diff --git a/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js
new file mode 100644
index 00000000..430a83e2
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js
@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge = require('merge-source-map');
+// .scss/.sass processor
+const scss = {
+    render(source, map, options) {
+        const nodeSass = require('node-sass');
+        const finalOptions = Object.assign({}, options, {
+            data: source,
+            file: options.filename,
+            outFile: options.filename,
+            sourceMap: !!map
+        });
+        try {
+            const result = nodeSass.renderSync(finalOptions);
+            if (map) {
+                return {
+                    code: result.css.toString(),
+                    map: merge(map, JSON.parse(result.map.toString())),
+                    errors: []
+                };
+            }
+            return { code: result.css.toString(), errors: [] };
+        }
+        catch (e) {
+            return { code: '', errors: [e] };
+        }
+    }
+};
+const sass = {
+    render(source, map, options) {
+        return scss.render(source, map, Object.assign({}, options, { indentedSyntax: true }));
+    }
+};
+// .less
+const less = {
+    render(source, map, options) {
+        const nodeLess = require('less');
+        let result;
+        let error = null;
+        nodeLess.render(source, Object.assign({}, options, { syncImport: true }), (err, output) => {
+            error = err;
+            result = output;
+        });
+        if (error)
+            return { code: '', errors: [error] };
+        if (map) {
+            return {
+                code: result.css.toString(),
+                map: merge(map, result.map),
+                errors: []
+            };
+        }
+        return { code: result.css.toString(), errors: [] };
+    }
+};
+// .styl
+const styl = {
+    render(source, map, options) {
+        const nodeStylus = require('stylus');
+        try {
+            const ref = nodeStylus(source);
+            Object.keys(options).forEach(key => ref.set(key, options[key]));
+            if (map)
+                ref.set('sourcemap', { inline: false, comment: false });
+            const result = ref.render();
+            if (map) {
+                return {
+                    code: result,
+                    map: merge(map, ref.sourcemap),
+                    errors: []
+                };
+            }
+            return { code: result, errors: [] };
+        }
+        catch (e) {
+            return { code: '', errors: [e] };
+        }
+    }
+};
+exports.processors = {
+    less,
+    sass,
+    scss,
+    styl,
+    stylus: styl
+};
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts
new file mode 100644
index 00000000..5f7668e0
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts
@@ -0,0 +1,8 @@
+import { ASTNode } from './utils';
+export interface AssetURLOptions {
+    [name: string]: string | string[];
+}
+declare const _default: (userOptions?: AssetURLOptions | undefined) => {
+    postTransformNode: (node: ASTNode) => void;
+};
+export default _default;
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js
new file mode 100644
index 00000000..ef95f951
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js
@@ -0,0 +1,44 @@
+"use strict";
+// vue compiler module for transforming `<tag>:<attribute>` to `require`
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const defaultOptions = {
+    video: ['src', 'poster'],
+    source: 'src',
+    img: 'src',
+    image: ['xlink:href', 'href']
+};
+exports.default = (userOptions) => {
+    const options = userOptions
+        ? Object.assign({}, defaultOptions, userOptions)
+        : defaultOptions;
+    return {
+        postTransformNode: (node) => {
+            transform(node, options);
+        }
+    };
+};
+function transform(node, options) {
+    for (const tag in options) {
+        if ((tag === '*' || node.tag === tag) && node.attrs) {
+            const attributes = options[tag];
+            if (typeof attributes === 'string') {
+                node.attrs.some(attr => rewrite(attr, attributes));
+            }
+            else if (Array.isArray(attributes)) {
+                attributes.forEach(item => node.attrs.some(attr => rewrite(attr, item)));
+            }
+        }
+    }
+}
+function rewrite(attr, name) {
+    if (attr.name === name) {
+        const value = attr.value;
+        // only transform static URLs
+        if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
+            attr.value = utils_1.urlToRequire(value.slice(1, -1));
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts
new file mode 100644
index 00000000..9c57ef90
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts
@@ -0,0 +1,5 @@
+import { ASTNode } from './utils';
+declare const _default: () => {
+    postTransformNode: (node: ASTNode) => void;
+};
+export default _default;
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js
new file mode 100644
index 00000000..398d065e
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js
@@ -0,0 +1,51 @@
+"use strict";
+// vue compiler module for transforming `img:srcset` to a number of `require`s
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+exports.default = () => ({
+    postTransformNode: (node) => {
+        transform(node);
+    }
+});
+// http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5
+const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
+function transform(node) {
+    const tags = ['img', 'source'];
+    if (tags.indexOf(node.tag) !== -1 && node.attrs) {
+        node.attrs.forEach(attr => {
+            if (attr.name === 'srcset') {
+                // same logic as in transform-require.js
+                const value = attr.value;
+                const isStatic = value.charAt(0) === '"' && value.charAt(value.length - 1) === '"';
+                if (!isStatic) {
+                    return;
+                }
+                const imageCandidates = value
+                    .substr(1, value.length - 2)
+                    .split(',')
+                    .map(s => {
+                    // The attribute value arrives here with all whitespace, except
+                    // normal spaces, represented by escape sequences
+                    const [url, descriptor] = s
+                        .replace(escapedSpaceCharacters, ' ')
+                        .trim()
+                        .split(' ', 2);
+                    return { require: utils_1.urlToRequire(url), descriptor };
+                });
+                // "require(url1)"
+                // "require(url1) 1x"
+                // "require(url1), require(url2)"
+                // "require(url1), require(url2) 2x"
+                // "require(url1) 1x, require(url2)"
+                // "require(url1) 1x, require(url2) 2x"
+                const code = imageCandidates
+                    .map(({ require, descriptor }) => `${require} + "${descriptor ? ' ' + descriptor : ''}, " + `)
+                    .join('')
+                    .slice(0, -6)
+                    .concat('"')
+                    .replace(/ \+ ""$/, '');
+                attr.value = code;
+            }
+        });
+    }
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts
new file mode 100644
index 00000000..f0b821ba
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts
@@ -0,0 +1,9 @@
+export interface Attr {
+    name: string;
+    value: string;
+}
+export interface ASTNode {
+    tag: string;
+    attrs: Attr[];
+}
+export declare function urlToRequire(url: string): string;
diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js
new file mode 100644
index 00000000..71224c12
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js
@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+function urlToRequire(url) {
+    const returnValue = `"${url}"`;
+    // same logic as in transform-require.js
+    const firstChar = url.charAt(0);
+    if (firstChar === '.' || firstChar === '~' || firstChar === '@') {
+        if (firstChar === '~') {
+            const secondChar = url.charAt(1);
+            url = url.slice(secondChar === '/' ? 2 : 1);
+        }
+        const uriParts = parseUriParts(url);
+        if (!uriParts.hash) {
+            return `require("${url}")`;
+        }
+        else {
+            // support uri fragment case by excluding it from
+            // the require and instead appending it as string;
+            // assuming that the path part is sufficient according to
+            // the above caseing(t.i. no protocol-auth-host parts expected)
+            return `require("${uriParts.path}") + "${uriParts.hash}"`;
+        }
+    }
+    return returnValue;
+}
+exports.urlToRequire = urlToRequire;
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ * @param urlString an url as a string
+ */
+function parseUriParts(urlString) {
+    // initialize return value
+    const returnValue = url_1.parse('');
+    if (urlString) {
+        // A TypeError is thrown if urlString is not a string
+        // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+        if ('string' === typeof urlString) {
+            // check is an uri
+            return url_1.parse(urlString); // take apart the uri
+        }
+    }
+    return returnValue;
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/types.d.ts b/node_modules/@vue/component-compiler-utils/dist/types.d.ts
new file mode 100644
index 00000000..73aefd4b
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/types.d.ts
@@ -0,0 +1,30 @@
+import { SFCDescriptor } from './parse';
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+export interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+export interface VueTemplateCompiler {
+    parseComponent(source: string, options?: any): SFCDescriptor;
+    compile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults;
+    ssrCompile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults;
+}
+export interface VueTemplateCompilerOptions {
+    modules?: Object[];
+}
+export interface VueTemplateCompilerParseOptions {
+    pad?: 'line' | 'space';
+}
+export interface VueTemplateCompilerResults {
+    ast: Object | void;
+    render: string;
+    staticRenderFns: string[];
+    errors: string[];
+    tips: string[];
+}
diff --git a/node_modules/@vue/component-compiler-utils/dist/types.js b/node_modules/@vue/component-compiler-utils/dist/types.js
new file mode 100644
index 00000000..c8ad2e54
--- /dev/null
+++ b/node_modules/@vue/component-compiler-utils/dist/types.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });