diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileStyle.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileStyle.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..078f5444a20be57be624ee8fe26ca6ac4b389ccf
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileStyle.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileStyle.js
new file mode 100644
index 0000000000000000000000000000000000000000..065dc116611acdcb696fcea515d74757bd30840b
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileStyle.js
@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = require('postcss');
+const trim_1 = __importDefault(require("./stylePlugins/trim"));
+const scoped_1 = __importDefault(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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileTemplate.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileTemplate.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b8654268f82e04e7713210cc0df58d8aa28a9f6
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileTemplate.d.ts
@@ -0,0 +1,24 @@
+import { VueTemplateCompiler, VueTemplateCompilerOptions, ErrorWithRange } 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;
+    prettify?: boolean;
+}
+export interface TemplateCompileResult {
+    ast: Object | undefined;
+    code: string;
+    source: string;
+    tips: (string | ErrorWithRange)[];
+    errors: (string | ErrorWithRange)[];
+}
+export declare function compileTemplate(options: TemplateCompileOptions): TemplateCompileResult;
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/index.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f7e9cf3e2ef26705b79be25fd8b86beca1f7c615
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/index.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8f4055569994baae29dd826f93433a4b5000a4e
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parse.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parse.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f82493e70b6e4269b07f0ef604accea2403cc9d9
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parseCustomBlocks.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parseCustomBlocks.js
new file mode 100644
index 0000000000000000000000000000000000000000..9debc81aa500b3462960925b006f1f06293fc024
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parseCustomBlocks.js
@@ -0,0 +1,52 @@
+const {
+  getPlatformFilterTag,
+  normalizeNodeModules
+} = require('@dcloudio/uni-cli-shared/lib/platform')
+
+const FILTER_TAG = getPlatformFilterTag()
+
+module.exports = function parseCustomBlocks(descriptor, options) {
+
+  if (!descriptor.template || !FILTER_TAG || options.isAppNVue) {
+    // delete customBlocks
+    descriptor.customBlocks.length = 0
+    return descriptor
+  }
+
+  const modules = Object.create(null)
+
+  descriptor.customBlocks = descriptor.customBlocks.filter(block => {
+    if (
+      block.attrs.module &&
+      (
+        block.type === FILTER_TAG ||
+        block.attrs.lang === FILTER_TAG
+      )
+    ) {
+      modules[block.attrs.module] = block
+      return true
+    }
+    if ( // renderjs
+      options.isAppView &&
+      (
+        block.type === 'renderjs' ||
+        block.attrs.lang === 'renderjs'
+      )
+    ) {
+      return true
+    }
+  })
+
+  if (Object.keys(modules).length) {
+    const filterModules = JSON.parse(JSON.stringify(modules))
+    Object.keys(filterModules).forEach(name => {
+      const filterModule = filterModules[name]
+      if (filterModule.attrs.src) {
+        filterModule.attrs.src = normalizeNodeModules(filterModule.attrs.src)
+      }
+    })
+    descriptor.template.attrs['filter-modules'] = JSON.stringify(filterModules)
+  }
+
+  return descriptor
+}
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..20c0dd03f6e42ddf52964afd600ccdbec7c2e491
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/scoped.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/scoped.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf11444408e463bd3f1651b1925bb3ecbda5ca2c
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/scoped.js
@@ -0,0 +1,99 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = __importStar(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;
+                // find the last child node to insert attribute selector
+                selector.each((n) => {
+                    // ">>>" combinator
+                    // and /deep/ alias for >>>, since >>> doesn't work in SASS
+                    if (n.type === 'combinator' &&
+                        (n.value === '>>>' || n.value === '/deep/')) {
+                        n.value = ' ';
+                        n.spaces.before = n.spaces.after = '';
+                        return false;
+                    }
+                    // in newer versions of sass, /deep/ support is also dropped, so add a ::v-deep alias
+                    if (n.type === 'pseudo' && n.value === '::v-deep') {
+                        n.value = n.spaces.before = n.spaces.after = '';
+                        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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a424c9313a162bb299e278df5d95fe95f8374a92
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts
@@ -0,0 +1,3 @@
+import * as postcss from 'postcss';
+declare const _default: postcss.Plugin<unknown>;
+export default _default;
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.js
new file mode 100644
index 0000000000000000000000000000000000000000..442e259cefffdd7fd63938de3c7cbc374ab1420e
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/stylePlugins/trim.js
@@ -0,0 +1,20 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss = __importStar(require("postcss"));
+exports.default = postcss.plugin('trim', () => (css) => {
+    css.walk(({ type, raws }) => {
+        if (type === 'rule' || type === 'atrule') {
+            if (raws.before)
+                raws.before = '\n';
+            if (raws.after)
+                raws.after = '\n';
+        }
+    });
+});
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc324a8c50066b3b7b9c115a5d278ba405cdb94e
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/styleProcessors/index.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/styleProcessors/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..03a65d3425f777b75d22b6efb116b901918f19e3
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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('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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f7668e0d314e5286b4496ac45fd36f57fcd8b40
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js
new file mode 100644
index 0000000000000000000000000000000000000000..6505a58945871ba3bda27d3050e81309a0007db7
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js
@@ -0,0 +1,46 @@
+"use strict";
+// vue compiler module for transforming `<tag>:<attribute>` to `require`
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const defaultOptions = {
+    audio: 'src',
+    video: ['src', 'poster'],
+    source: 'src',
+    img: 'src',
+    image: ['xlink:href', 'href'],
+    use: ['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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c57ef90f6f82ccba17deb90af644891733aed2c
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js
new file mode 100644
index 0000000000000000000000000000000000000000..398d065eed6656e7714c07fc55ec7acc504aa584
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0b821ba15ca83d926f372ac7f477481ea9714f0
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..71224c12ae39f636947ab0452bab8b6603fc4538
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@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/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6cddece664d2af63db716c1dbface97c8f814af4
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.d.ts
@@ -0,0 +1,40 @@
+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[];
+    outputSourceRange?: boolean;
+    whitespace?: 'preserve' | 'condense';
+    directives?: {
+        [key: string]: Function;
+    };
+}
+export interface VueTemplateCompilerParseOptions {
+    pad?: 'line' | 'space';
+}
+export interface ErrorWithRange {
+    msg: string;
+    start: number;
+    end: number;
+}
+export interface VueTemplateCompilerResults {
+    ast: Object | undefined;
+    render: string;
+    staticRenderFns: string[];
+    errors: (string | ErrorWithRange)[];
+    tips: (string | ErrorWithRange)[];
+}
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/types.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/API.md b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/API.md
new file mode 100644
index 0000000000000000000000000000000000000000..ceee157e96977b8300fa2fd6a85f7b3f65dd7339
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/API.md
@@ -0,0 +1,873 @@
+# API Documentation
+
+*Please use only this documented API when working with the parser. Methods
+not documented here are subject to change at any point.*
+
+## `parser` function
+
+This is the module's main entry point.
+
+```js
+const parser = require('postcss-selector-parser');
+```
+
+### `parser([transform], [options])`
+
+Creates a new `processor` instance
+
+```js
+const processor = parser();
+```
+
+Or, with optional transform function
+
+```js
+const transform = selectors => {
+    selectors.walkUniversals(selector => {
+        selector.remove();
+    });
+};
+
+const processor = parser(transform)
+
+// Example
+const result = processor.processSync('*.class');
+// => .class
+```
+
+[See processor documentation](#processor)
+
+Arguments:
+
+* `transform (function)`: Provide a function to work with the parsed AST.
+* `options (object)`: Provide default options for all calls on the returned `Processor`.
+
+### `parser.attribute([props])`
+
+Creates a new attribute selector.
+
+```js
+parser.attribute({attribute: 'href'});
+// => [href]
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.className([props])`
+
+Creates a new class selector.
+
+```js
+parser.className({value: 'button'});
+// => .button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.combinator([props])`
+
+Creates a new selector combinator.
+
+```js
+parser.combinator({value: '+'});
+// => +
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+Notes:
+* **Descendant Combinators** The value of descendant combinators created by the
+  parser always just a single space (`" "`). For descendant selectors with no
+  comments, additional space is now stored in `node.spaces.before`. Depending
+  on the location of comments, additional spaces may be stored in
+  `node.raws.spaces.before`, `node.raws.spaces.after`, or `node.raws.value`.
+* **Named Combinators** Although, nonstandard and unlikely to ever become a standard,
+  named combinators like `/deep/` and `/for/` are parsed as combinators. The
+  `node.value` is name after being unescaped and normalized as lowercase. The
+  original value for the combinator name is stored in `node.raws.value`.
+
+
+### `parser.comment([props])`
+
+Creates a new comment.
+
+```js
+parser.comment({value: '/* Affirmative, Dave. I read you. */'});
+// => /* Affirmative, Dave. I read you. */
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.id([props])`
+
+Creates a new id selector.
+
+```js
+parser.id({value: 'search'});
+// => #search
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.nesting([props])`
+
+Creates a new nesting selector.
+
+```js
+parser.nesting();
+// => &
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.pseudo([props])`
+
+Creates a new pseudo selector.
+
+```js
+parser.pseudo({value: '::before'});
+// => ::before
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.root([props])`
+
+Creates a new root node.
+
+```js
+parser.root();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.selector([props])`
+
+Creates a new selector node.
+
+```js
+parser.selector();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.string([props])`
+
+Creates a new string node.
+
+```js
+parser.string();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.tag([props])`
+
+Creates a new tag selector.
+
+```js
+parser.tag({value: 'button'});
+// => button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.universal([props])`
+
+Creates a new universal selector.
+
+```js
+parser.universal();
+// => *
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+## Node types
+
+### `node.type`
+
+A string representation of the selector type. It can be one of the following;
+`attribute`, `class`, `combinator`, `comment`, `id`, `nesting`, `pseudo`,
+`root`, `selector`, `string`, `tag`, or `universal`. Note that for convenience,
+these constants are exposed on the main `parser` as uppercased keys. So for
+example you can get `id` by querying `parser.ID`.
+
+```js
+parser.attribute({attribute: 'href'}).type;
+// => 'attribute'
+```
+
+### `node.parent`
+
+Returns the parent node.
+
+```js
+root.nodes[0].parent === root;
+```
+
+### `node.toString()`, `String(node)`, or `'' + node`
+
+Returns a string representation of the node.
+
+```js
+const id = parser.id({value: 'search'});
+console.log(String(id));
+// => #search
+```
+
+### `node.next()` & `node.prev()`
+
+Returns the next/previous child of the parent node.
+
+```js
+const next = id.next();
+if (next && next.type !== 'combinator') {
+    throw new Error('Qualified IDs are not allowed!');
+}
+```
+
+### `node.replaceWith(node)`
+
+Replace a node with another.
+
+```js
+const attr = selectors.first.first;
+const className = parser.className({value: 'test'});
+attr.replaceWith(className);
+```
+
+Arguments:
+
+* `node`: The node to substitute the original with.
+
+### `node.remove()`
+
+Removes the node from its parent node.
+
+```js
+if (node.type === 'id') {
+    node.remove();
+}
+```
+
+### `node.clone()`
+
+Returns a copy of a node, detached from any parent containers that the
+original might have had.
+
+```js
+const cloned = parser.id({value: 'search'});
+String(cloned);
+
+// => #search
+```
+
+### `node.isAtPosition(line, column)`
+
+Return a `boolean` indicating whether this node includes the character at the
+position of the given line and column. Returns `undefined` if the nodes lack
+sufficient source metadata to determine the position.
+
+Arguments:
+
+* `line`: 1-index based line number relative to the start of the selector.
+* `column`: 1-index based column number relative to the start of the selector.
+
+### `node.spaces`
+
+Extra whitespaces around the node will be moved into `node.spaces.before` and
+`node.spaces.after`. So for example, these spaces will be moved as they have
+no semantic meaning:
+
+```css
+      h1     ,     h2   {}
+```
+
+For descendent selectors, the value is always a single space.
+
+```css
+h1        h2 {}
+```
+
+Additional whitespace is found in either the `node.spaces.before` and `node.spaces.after` depending on the presence of comments or other whitespace characters. If the actual whitespace does not start or end with a single space, the node's raw value is set to the actual space(s) found in the source.
+
+### `node.source`
+
+An object describing the node's start/end, line/column source position.
+
+Within the following CSS, the `.bar` class node ...
+
+```css
+.foo,
+  .bar {}
+```
+
+... will contain the following `source` object.
+
+```js
+source: {
+    start: {
+        line: 2,
+        column: 3
+    },
+    end: {
+        line: 2,
+        column: 6
+    }
+}
+```
+
+### `node.sourceIndex`
+
+The zero-based index of the node within the original source string.
+
+Within the following CSS, the `.baz` class node will have a `sourceIndex` of `12`.
+
+```css
+.foo, .bar, .baz {}
+```
+
+## Container types
+
+The `root`, `selector`, and `pseudo` nodes have some helper methods for working
+with their children.
+
+### `container.nodes`
+
+An array of the container's children.
+
+```js
+// Input: h1 h2
+selectors.at(0).nodes.length   // => 3
+selectors.at(0).nodes[0].value // => 'h1'
+selectors.at(0).nodes[1].value // => ' '
+```
+
+### `container.first` & `container.last`
+
+The first/last child of the container.
+
+```js
+selector.first === selector.nodes[0];
+selector.last === selector.nodes[selector.nodes.length - 1];
+```
+
+### `container.at(index)`
+
+Returns the node at position `index`.
+
+```js
+selector.at(0) === selector.first;
+selector.at(0) === selector.nodes[0];
+```
+
+Arguments:
+
+* `index`: The index of the node to return.
+
+### `container.atPosition(line, column)`
+
+Returns the node at the source position `index`.
+
+```js
+selector.at(0) === selector.first;
+selector.at(0) === selector.nodes[0];
+```
+
+Arguments:
+
+* `index`: The index of the node to return.
+
+### `container.index(node)`
+
+Return the index of the node within its container.
+
+```js
+selector.index(selector.nodes[2]) // => 2
+```
+
+Arguments:
+
+* `node`: A node within the current container.
+
+### `container.length`
+
+Proxy to the length of the container's nodes.
+
+```js
+container.length === container.nodes.length
+```
+
+### `container` Array iterators
+
+The container class provides proxies to certain Array methods; these are:
+
+* `container.map === container.nodes.map`
+* `container.reduce === container.nodes.reduce`
+* `container.every === container.nodes.every`
+* `container.some === container.nodes.some`
+* `container.filter === container.nodes.filter`
+* `container.sort === container.nodes.sort`
+
+Note that these methods only work on a container's immediate children; recursive
+iteration is provided by `container.walk`.
+
+### `container.each(callback)`
+
+Iterate the container's immediate children, calling `callback` for each child.
+You may return `false` within the callback to break the iteration.
+
+```js
+let className;
+selectors.each((selector, index) => {
+    if (selector.type === 'class') {
+        className = selector.value;
+        return false;
+    }
+});
+```
+
+Note that unlike `Array#forEach()`, this iterator is safe to use whilst adding
+or removing nodes from the container.
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  and `index` arguments.
+
+### `container.walk(callback)`
+
+Like `container#each`, but will also iterate child nodes as long as they are
+`container` types.
+
+```js
+selectors.walk((selector, index) => {
+    // all nodes
+});
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  and `index` arguments.
+
+This iterator is safe to use whilst mutating `container.nodes`,
+like `container#each`.
+
+### `container.walk` proxies
+
+The container class provides proxy methods for iterating over types of nodes,
+so that it is easier to write modules that target specific selectors. Those
+methods are:
+
+* `container.walkAttributes`
+* `container.walkClasses`
+* `container.walkCombinators`
+* `container.walkComments`
+* `container.walkIds`
+* `container.walkNesting`
+* `container.walkPseudos`
+* `container.walkTags`
+* `container.walkUniversals`
+
+### `container.split(callback)`
+
+This method allows you to split a group of nodes by returning `true` from
+a callback. It returns an array of arrays, where each inner array corresponds
+to the groups that you created via the callback.
+
+```js
+// (input) => h1 h2>>h3
+const list = selectors.first.split(selector => {
+    return selector.type === 'combinator';
+});
+
+// (node values) => [['h1', ' '], ['h2', '>>'], ['h3']]
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  as an argument.
+
+### `container.prepend(node)` & `container.append(node)`
+
+Add a node to the start/end of the container. Note that doing so will set
+the parent property of the node to this container.
+
+```js
+const id = parser.id({value: 'search'});
+selector.append(id);
+```
+
+Arguments:
+
+* `node`: The node to add.
+
+### `container.insertBefore(old, new)` & `container.insertAfter(old, new)`
+
+Add a node before or after an existing node in a container:
+
+```js
+selectors.walk(selector => {
+    if (selector.type !== 'class') {
+        const className = parser.className({value: 'theme-name'});
+        selector.parent.insertAfter(selector, className);
+    }
+});
+```
+
+Arguments:
+
+* `old`: The existing node in the container.
+* `new`: The new node to add before/after the existing node.
+
+### `container.removeChild(node)`
+
+Remove the node from the container. Note that you can also use
+`node.remove()` if you would like to remove just a single node.
+
+```js
+selector.length // => 2
+selector.remove(id)
+selector.length // => 1;
+id.parent       // undefined
+```
+
+Arguments:
+
+* `node`: The node to remove.
+
+### `container.removeAll()` or `container.empty()`
+
+Remove all children from the container.
+
+```js
+selector.removeAll();
+selector.length // => 0
+```
+
+## Root nodes
+
+A root node represents a comma separated list of selectors. Indeed, all
+a root's `toString()` method does is join its selector children with a ','.
+Other than this, it has no special functionality and acts like a container.
+
+### `root.trailingComma`
+
+This will be set to `true` if the input has a trailing comma, in order to
+support parsing of legacy CSS hacks.
+
+## Selector nodes
+
+A selector node represents a single complex selector. For example, this
+selector string `h1 h2 h3, [href] > p`, is represented as two selector nodes.
+It has no special functionality of its own.
+
+## Pseudo nodes
+
+A pseudo selector extends a container node; if it has any parameters of its
+own (such as `h1:not(h2, h3)`), they will be its children. Note that the pseudo
+`value` will always contain the colons preceding the pseudo identifier. This
+is so that both `:before` and `::before` are properly represented in the AST.
+
+## Attribute nodes
+
+### `attribute.quoted`
+
+Returns `true` if the attribute's value is wrapped in quotation marks, false if it is not.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* false */
+[href='foo'] /* true */
+[href="foo"] /* true */
+[href] /* undefined */
+```
+
+### `attribute.qualifiedAttribute`
+
+Returns the attribute name qualified with the namespace if one is given.
+
+### `attribute.offsetOf(part)`
+
+ Returns the offset of the attribute part specified relative to the
+ start of the node of the output string. This is useful in raising
+ error messages about a specific part of the attribute, especially
+ in combination with `attribute.sourceIndex`.
+
+ Returns `-1` if the name is invalid or the value doesn't exist in this
+ attribute.
+
+ The legal values for `part` are:
+
+ * `"ns"` - alias for "namespace"
+ * `"namespace"` - the namespace if it exists.
+ * `"attribute"` - the attribute name
+ * `"attributeNS"` - the start of the attribute or its namespace
+ * `"operator"` - the match operator of the attribute
+ * `"value"` - The value (string or identifier)
+ * `"insensitive"` - the case insensitivity flag
+
+### `attribute.raws.unquoted`
+
+Returns the unquoted content of the attribute's value.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* foo */
+[href='foo'] /* foo */
+[href="foo"] /* foo */
+[href] /* undefined */
+```
+
+### `attribute.spaces`
+
+Like `node.spaces` with the `before` and `after` values containing the spaces
+around the element, the parts of the attribute can also have spaces before
+and after them. The for each of `attribute`, `operator`, `value` and
+`insensitive` there is corresponding property of the same nam in
+`node.spaces` that has an optional `before` or `after` string containing only
+whitespace.
+
+Note that corresponding values in `attributes.raws.spaces` contain values
+including any comments. If set, these values will override the
+`attribute.spaces` value. Take care to remove them if changing
+`attribute.spaces`.
+
+### `attribute.raws`
+
+The raws object stores comments and other information necessary to re-render
+the node exactly as it was in the source.
+
+If a comment is embedded within the identifiers for the `namespace`, `attribute`
+or `value` then a property is placed in the raws for that value containing the full source of the propery including comments.
+
+If a comment is embedded within the space between parts of the attribute
+then the raw for that space is set accordingly.
+
+Setting an attribute's property `raws` value to be deleted.
+
+For now, changing the spaces required also updating or removing any of the
+raws values that override them.
+
+Example: `[ /*before*/ href /* after-attr */ = /* after-operator */ te/*inside-value*/st/* wow */ /*omg*/i/*bbq*/ /*whodoesthis*/]` would parse as:
+
+```js
+{
+  attribute: "href",
+  operatator: "=",
+  value: "test",
+  spaces: {
+    before: '',
+    after: '',
+    attribute: { before: '  ', after: '  ' },
+    operator: { after: '  ' },
+    value: { after: ' ' },
+    insensitive: { after: ' ' }
+  },
+  raws: {
+    spaces: {
+      attribute: { before: ' /*before*/ ', after: ' /* after-attr */ ' },
+      operator: { after: ' /* after-operator */ ' },
+      value: { after: '/* wow */ /*omg*/' },
+      insensitive: { after: '/*bbq*/ /*whodoesthis*/' }
+    },
+    unquoted: 'test',
+    value: 'te/*inside-value*/st'
+  }
+}
+```
+
+## `Processor`
+
+### `ProcessorOptions`
+
+* `lossless` - When `true`, whitespace is preserved. Defaults to `true`.
+* `updateSelector` - When `true`, if any processor methods are passed a postcss
+  `Rule` node instead of a string, then that Rule's selector is updated
+  with the results of the processing. Defaults to `true`.
+
+### `process|processSync(selectors, [options])`
+
+Processes the `selectors`, returning a string from the result of processing.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+**Example:**
+
+```js
+const parser = require("postcss-selector-parser");
+const processor = parser();
+
+let result = processor.processSync(' .class');
+console.log(result);
+// =>  .class
+
+// Asynchronous operation
+let promise = processor.process(' .class').then(result => {
+    console.log(result)
+    // => .class
+});
+
+// To have the parser normalize whitespace values, utilize the options
+result = processor.processSync('  .class  ', {lossless: false});
+console.log(result);
+// => .class
+
+// For better syntax errors, pass a PostCSS Rule node.
+const postcss = require('postcss');
+rule = postcss.rule({selector: ' #foo    > a,  .class  '});
+processor.process(rule, {lossless: false, updateSelector: true}).then(result => {
+    console.log(result);
+    // => #foo>a,.class
+    console.log("rule:", rule.selector);
+    // => rule: #foo>a,.class
+})
+```
+
+Arguments:
+
+* `selectors (string|postcss.Rule)`: Either a selector string or a PostCSS Rule
+  node.
+* `[options] (object)`: Process options
+
+
+### `ast|astSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the `Root` node of the result
+instead of a string.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### `transform|transformSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the value returned by the
+processor callback.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### Error Handling Within Selector Processors
+
+The root node passed to the selector processor callback
+has a method `error(message, options)` that returns an
+error object. This method should always be used to raise
+errors relating to the syntax of selectors. The options
+to this method are passed to postcss's error constructor
+([documentation](http://api.postcss.org/Container.html#error)).
+
+#### Async Error Example
+
+```js
+let processor = (root) => {
+    return new Promise((resolve, reject) => {
+        root.walkClasses((classNode) => {
+            if (/^(.*)[-_]/.test(classNode.value)) {
+                let msg = "classes may not have underscores or dashes in them";
+                reject(root.error(msg, {
+                    index: classNode.sourceIndex + RegExp.$1.length + 1,
+                    word: classNode.value
+                }));
+            }
+        });
+        resolve();
+    });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+    return (root) => {
+        let promises = [];
+        root.walkRules(rule => {
+            promises.push(selectorProcessor.process(rule));
+        });
+        return Promise.all(promises);
+    };
+});
+postcss(plugin()).process(`
+.foo-bar {
+  color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+//     |     ^
+//   2 |   color: red;
+//   3 | }
+```
+
+#### Synchronous Error Example
+
+```js
+let processor = (root) => {
+    root.walkClasses((classNode) => {
+        if (/.*[-_]/.test(classNode.value)) {
+            let msg = "classes may not have underscores or dashes in them";
+            throw root.error(msg, {
+                index: classNode.sourceIndex,
+                word: classNode.value
+            });
+        }
+    });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+    return (root) => {
+        root.walkRules(rule => {
+            selectorProcessor.processSync(rule);
+        });
+    };
+});
+postcss(plugin()).process(`
+.foo-bar {
+  color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+//     |     ^
+//   2 |   color: red;
+//   3 | }
+```
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/CHANGELOG.md b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..3e66a210fa46de3aea7dfce490445ab19e4c1077
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/CHANGELOG.md
@@ -0,0 +1,466 @@
+# 5.0.0
+
+- Allow escaped dot within class name.
+- Update PostCSS to 7.0.7 (patch)
+
+# 5.0.0-rc.4
+
+- Fixed and issue where comments immediately after an insensitive
+  (in attribute) were not parsed correctly.
+- Updated `cssesc` to 2.0.0 (major).
+- Removed outdated integration tests.
+- Added tests for custom selectors, tags with attributes, the universal
+  selector with pseudos, and tokens after combinators.
+
+# 5.0.0-rc.1
+
+To ease adoption of the v5.0 release, we have relaxed the node version
+check performed by npm at installation time to allow for node 4, which
+remains officially unsupported, but likely to continue working for the
+time being.
+
+# 5.0.0-rc.0
+
+This release has **BREAKING CHANGES** that were required to fix regressions
+in 4.0.0 and to make the Combinator Node API consistent for all combinator
+types. Please read carefully.
+
+## Summary of Changes
+
+* The way a descendent combinator that isn't a single space character (E.g. `.a  .b`) is stored in the AST has changed.
+* Named Combinators (E.g. `.a /for/ .b`) are now properly parsed as a combinator.
+* It is now possible to look up a node based on the source location of a character in that node and to query nodes if they contain some character.
+* Several bug fixes that caused the parser to hang and run out of memory when a `/` was encountered have been fixed.
+* The minimum supported version of Node is now `v6.0.0`.
+
+### Changes to the Descendent Combinator
+
+In prior releases, the value of a descendant combinator with multiple spaces included all the spaces.
+
+* `.a   .b`: Extra spaces are now stored as space before.
+  - Old & Busted:
+    - `combinator.value === "   "`
+  - New hotness:
+    - `combinator.value === " " && combinator.spaces.before === "  "`
+* `.a   /*comment*/.b`: A comment at the end of the combinator causes extra space to become after space.
+  - Old & Busted:
+    - `combinator.value === "   "`
+    - `combinator.raws.value === "   /*comment/"`
+  - New hotness:
+    - `combinator.value === " "`
+    - `combinator.spaces.after === "  "`
+    - `combinator.raws.spaces.after === "  /*comment*/"`
+* `.a<newline>.b`: whitespace that doesn't start or end with a single space character is stored as a raw value.
+  - Old & Busted:
+    - `combinator.value === "\n"`
+    - `combinator.raws.value === undefined`
+  - New hotness:
+    - `combinator.value === " "`
+    - `combinator.raws.value === "\n"`
+
+### Support for "Named Combinators"
+
+Although, nonstandard and unlikely to ever become a standard, combinators like `/deep/` and `/for/` are now properly supported.
+
+Because they've been taken off the standardization track, there is no spec-official name for combinators of the form `/<ident>/`. However, I talked to [Tab Atkins](https://twitter.com/tabatkins) and we agreed to call them "named combinators" so now they are called that.
+
+Before this release such named combinators were parsed without intention and generated three nodes of type `"tag"` where the first and last nodes had a value of `"/"`.
+
+* `.a /for/ .b` is parsed as a combinator.
+  - Old & Busted:
+    - `root.nodes[0].nodes[1].type === "tag"`
+    - `root.nodes[0].nodes[1].value === "/"`
+  - New hotness:
+    - `root.nodes[0].nodes[1].type === "combinator"`
+    - `root.nodes[0].nodes[1].value === "/for/"`
+* `.a /F\6fR/ .b` escapes are handled and uppercase is normalized.
+  - Old & Busted:
+    - `root.nodes[0].nodes[2].type === "tag"`
+    - `root.nodes[0].nodes[2].value === "F\\6fR"`
+  - New hotness:
+    - `root.nodes[0].nodes[1].type === "combinator"`
+    - `root.nodes[0].nodes[1].value === "/for/"`
+    - `root.nodes[0].nodes[1].raws.value === "/F\\6fR/"`
+
+### Source position checks and lookups
+
+A new API was added to look up a node based on the source location.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+// You can find the most specific node for any given character
+let combinator = selectorParser.astSync(".a > .b").atPosition(1,4);
+combinator.toString() === " > ";
+// You can check if a node includes a specific character
+// Whitespace surrounding the node that is owned by that node
+// is included in the check.
+[2,3,4,5,6].map(column => combinator.isAtPosition(1, column));
+// => [false, true, true, true, false]
+```
+
+# 4.0.0
+
+This release has **BREAKING CHANGES** that were required to fix bugs regarding values with escape sequences. Please read carefully.
+
+* **Identifiers with escapes** - CSS escape sequences are now hidden from the public API by default.
+  The normal value of a node like a class name or ID, or an aspect of a node such as attribute
+  selector's value, is unescaped. Escapes representing Non-ascii characters are unescaped into
+  unicode characters. For example: `bu\tton, .\31 00, #i\2764\FE0Fu, [attr="value is \"quoted\""]`
+  will parse respectively to the values `button`, `100`, `i❤️u`, `value is "quoted"`.
+  The original escape sequences for these values can be found in the corresponding property name
+  in `node.raws`. Where possible, deprecation warnings were added, but the nature
+  of escape handling makes it impossible to detect what is escaped or not. Our expectation is
+  that most users are neither expecting nor handling escape sequences in their use of this library,
+  and so for them, this is a bug fix. Users who are taking care to handle escapes correctly can
+  now update their code to remove the escape handling and let us do it for them.
+
+* **Mutating values with escapes** - When you make an update to a node property that has escape handling
+  The value is assumed to be unescaped, and any special characters are escaped automatically and
+  the corresponding `raws` value is immediately updated. This can result in changes to the original
+  escape format. Where the exact value of the escape sequence is important there are methods that
+  allow both values to be set in conjunction. There are a number of new convenience methods for
+  manipulating values that involve escapes, especially for attributes values where the quote mark
+  is involved. See https://github.com/postcss/postcss-selector-parser/pull/133 for an extensive
+  write-up on these changes.
+
+
+**Upgrade/API Example**
+
+In `3.x` there was no unescape handling and internal consistency of several properties was the caller's job to maintain. It was very easy for the developer
+to create a CSS file that did not parse correctly when some types of values
+were in use.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value"});
+attr.value; // => "a-value"
+attr.toString(); // => [id=a-value]
+// Add quotes to an attribute's value.
+// All these values have to be set by the caller to be consistent:
+// no internal consistency is maintained.
+attr.raws.unquoted = attr.value
+attr.value = "'" + attr.value + "'";
+attr.value; // => "'a-value'"
+attr.quoted = true;
+attr.toString();  // => "[id='a-value']"
+```
+
+In `4.0` there is a convenient API for setting and mutating values
+that may need escaping. Especially for attributes.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+
+// The constructor requires you specify the exact escape sequence
+let className = selectorParser.className({value: "illegal class name", raws: {value: "illegal\\ class\\ name"}});
+className.toString(); // => '.illegal\\ class\\ name'
+
+// So it's better to set the value as a property
+className = selectorParser.className();
+// Most properties that deal with identifiers work like this
+className.value = "escape for me";
+className.value; // => 'escape for me'
+className.toString(); // => '.escape\\ for\\ me'
+
+// emoji and all non-ascii are escaped to ensure it works in every css file.
+className.value = "😱🦄😍";
+className.value; // => '😱🦄😍'
+className.toString(); // => '.\\1F631\\1F984\\1F60D'
+
+// you can control the escape sequence if you want, or do bad bad things
+className.setPropertyAndEscape('value', 'xxxx', 'yyyy');
+className.value; // => "xxxx"
+className.toString(); // => ".yyyy"
+
+// Pass a value directly through to the css output without escaping it. 
+className.setPropertyWithoutEscape('value', '$REPLACE_ME$');
+className.value; // => "$REPLACE_ME$"
+className.toString(); // => ".$REPLACE_ME$"
+
+// The biggest changes are to the Attribute class
+// passing quoteMark explicitly is required to avoid a deprecation warning.
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value", quoteMark: null});
+attr.toString(); // => "[id=a-value]"
+// Get the value with quotes on it and any necessary escapes.
+// This is the same as reading attr.value in 3.x.
+attr.getQuotedValue(); // => "a-value";
+attr.quoteMark; // => null
+
+// Add quotes to an attribute's value.
+attr.quoteMark = "'"; // This is all that's required.
+attr.toString(); // => "[id='a-value']"
+attr.quoted; // => true
+// The value is still the same, only the quotes have changed.
+attr.value; // => a-value
+attr.getQuotedValue(); // => "'a-value'";
+
+// deprecated assignment, no warning because there's no escapes
+attr.value = "new-value";
+// no quote mark is needed so it is removed
+attr.getQuotedValue(); // => "new-value";
+
+// deprecated assignment, 
+attr.value = "\"a 'single quoted' value\"";
+// > (node:27859) DeprecationWarning: Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.
+attr.getQuotedValue(); // => '"a \'single quoted\' value"';
+// quote mark inferred from first and last characters.
+attr.quoteMark; // => '"'
+
+// setValue takes options to make manipulating the value simple.
+attr.setValue('foo', {smart: true});
+// foo doesn't require any escapes or quotes.
+attr.toString(); // => '[id=foo]'
+attr.quoteMark; // => null 
+
+// An explicit quote mark can be specified
+attr.setValue('foo', {quoteMark: '"'});
+attr.toString(); // => '[id="foo"]'
+
+// preserves quote mark by default
+attr.setValue('bar');
+attr.toString(); // => '[id="bar"]'
+attr.quoteMark = null;
+attr.toString(); // => '[id=bar]'
+
+// with no arguments, it preserves quote mark even when it's not a great idea
+attr.setValue('a value \n that should be quoted');
+attr.toString(); // => '[id=a\\ value\\ \\A\\ that\\ should\\ be\\ quoted]'
+
+// smart preservation with a specified default
+attr.setValue('a value \n that should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a value \\A  that should be quoted']"
+attr.quoteMark = '"';
+// => '[id="a value \\A  that should be quoted"]'
+
+// this keeps double quotes because it wants to quote the value and the existing value has double quotes.
+attr.setValue('this should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => '[id="this should be quoted"]'
+
+// picks single quotes because the value has double quotes
+attr.setValue('a "double quoted" value', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a "double quoted" value']"
+
+// setPropertyAndEscape lets you do anything you want. Even things that are a bad idea and illegal.
+attr.setPropertyAndEscape('value', 'xxxx', 'the password is 42');
+attr.value; // => "xxxx"
+attr.toString(); // => "[id=the password is 42]"
+
+// Pass a value directly through to the css output without escaping it. 
+attr.setPropertyWithoutEscape('value', '$REPLACEMENT$');
+attr.value; // => "$REPLACEMENT$"
+attr.toString(); // => "[id=$REPLACEMENT$]"
+```
+
+# 3.1.2
+
+* Fix: Removed dot-prop dependency since it's no longer written in es5.
+
+# 3.1.1
+
+* Fix: typescript definitions weren't in the published package.
+
+# 3.1.0
+
+* Fixed numerous bugs in attribute nodes relating to the handling of comments
+  and whitespace. There's significant changes to `attrNode.spaces` and `attrNode.raws` since the `3.0.0` release.
+* Added `Attribute#offsetOf(part)` to get the offset location of
+  attribute parts like `"operator"` and `"value"`. This is most
+  often added to `Attribute#sourceIndex` for error reporting.
+
+# 3.0.0
+
+## Breaking changes
+
+* Some tweaks to the tokenizer/attribute selector parsing mean that whitespace
+  locations might be slightly different to the 2.x code.
+* Better attribute selector parsing with more validation; postcss-selector-parser
+  no longer uses regular expressions to parse attribute selectors.
+* Added an async API (thanks to @jacobp100); the default `process` API is now
+  async, and the sync API is now accessed through `processSync` instead.
+* `process()` and `processSync()` now return a string instead of the Processor
+  instance.
+* Tweaks handling of Less interpolation (thanks to @jwilsson).
+* Removes support for Node 0.12.
+
+## Other changes
+
+* `ast()` and `astSync()` methods have been added to the `Processor`. These
+  return the `Root` node of the selectors after processing them.
+* `transform()` and `transformSync()` methods have been added to the
+  `Processor`. These return the value returned by the processor callback
+  after processing the selectors.
+* Set the parent when inserting a node (thanks to @chriseppstein).
+* Correctly adjust indices when using insertBefore/insertAfter (thanks to @tivac).
+* Fixes handling of namespaces with qualified tag selectors.
+* `process`, `ast` and `transform` (and their sync variants) now accept a
+  `postcss` rule node. When provided, better errors are generated and selector
+  processing is automatically set back to the rule selector (unless the `updateSelector` option is set to `false`.)
+* Now more memory efficient when tokenizing selectors.
+
+### Upgrade hints
+
+The pattern of:
+
+`rule.selector = processor.process(rule.selector).result.toString();`
+
+is now:
+
+`processor.processSync(rule)`
+
+# 2.2.3
+
+* Resolves an issue where the parser would not reduce multiple spaces between an
+  ampersand and another simple selector in lossy mode (thanks to @adam-26).
+
+# 2.2.2
+
+* No longer hangs on an unescaped semicolon; instead the parser will throw
+  an exception for these cases.
+
+# 2.2.1
+
+* Allows a consumer to specify whitespace tokens when creating a new Node
+  (thanks to @Semigradsky).
+
+# 2.2.0
+
+* Added a new option to normalize whitespace when parsing the selector string
+  (thanks to @adam-26).
+
+# 2.1.1
+
+* Better unquoted value handling within attribute selectors
+  (thanks to @evilebottnawi).
+
+# 2.1.0
+
+* Added: Use string constants for all node types & expose them on the main
+  parser instance (thanks to @Aweary).
+
+# 2.0.0
+
+This release contains the following breaking changes:
+
+* Renamed all `eachInside` iterators to `walk`. For example, `eachTag` is now
+  `walkTags`, and `eachInside` is now `walk`.
+* Renamed `Node#removeSelf()` to `Node#remove()`.
+* Renamed `Container#remove()` to `Container#removeChild()`.
+* Renamed `Node#raw` to `Node#raws` (thanks to @davidtheclark).
+* Now parses `&` as the *nesting* selector, rather than a *tag* selector.
+* Fixes misinterpretation of Sass interpolation (e.g. `#{foo}`) as an
+  id selector (thanks to @davidtheclark).
+
+and;
+
+* Fixes parsing of attribute selectors with equals signs in them
+  (e.g. `[data-attr="foo=bar"]`) (thanks to @montmanu).
+* Adds `quoted` and `raw.unquoted` properties to attribute nodes
+  (thanks to @davidtheclark).
+
+# 1.3.3
+
+* Fixes an infinite loop on `)` and `]` tokens when they had no opening pairs.
+  Now postcss-selector-parser will throw when it encounters these lone tokens.
+
+# 1.3.2
+
+* Now uses plain integers rather than `str.charCodeAt(0)` for compiled builds.
+
+# 1.3.1
+
+* Update flatten to v1.x (thanks to @shinnn).
+
+# 1.3.0
+
+* Adds a new node type, `String`, to fix a crash on selectors such as
+  `foo:bar("test")`.
+
+# 1.2.1
+
+* Fixes a crash when the parser encountered a trailing combinator.
+
+# 1.2.0
+
+* A more descriptive error is thrown when the parser expects to find a
+  pseudo-class/pseudo-element (thanks to @ashelley).
+* Adds support for line/column locations for selector nodes, as well as a
+  `Node#sourceIndex` method (thanks to @davidtheclark).
+
+# 1.1.4
+
+* Fixes a crash when a selector started with a `>` combinator. The module will
+  now no longer throw if a selector has a leading/trailing combinator node.
+
+# 1.1.3
+
+* Fixes a crash on `@` tokens.
+
+# 1.1.2
+
+* Fixes an infinite loop caused by using parentheses in a non-pseudo element
+  context.
+
+# 1.1.1
+
+* Fixes a crash when a backslash ended a selector string.
+
+# 1.1.0
+
+* Adds support for replacing multiple nodes at once with `replaceWith`
+  (thanks to @jonathantneal).
+* Parser no longer throws on sequential IDs and trailing commas, to support
+  parsing of selector hacks.
+
+# 1.0.1
+
+* Fixes using `insertAfter` and `insertBefore` during iteration.
+
+# 1.0.0
+
+* Adds `clone` and `replaceWith` methods to nodes.
+* Adds `insertBefore` and `insertAfter` to containers.
+* Stabilises API.
+
+# 0.0.5
+
+* Fixes crash on extra whitespace inside a pseudo selector's parentheses.
+* Adds sort function to the container class.
+* Enables the parser to pass its input through without transforming.
+* Iteration-safe `each` and `eachInside`.
+
+# 0.0.4
+
+* Tidy up redundant duplication.
+* Fixes a bug where the parser would loop infinitely on universal selectors
+  inside pseudo selectors.
+* Adds `length` getter and `eachInside`, `map`, `reduce` to the container class.
+* When a selector has been removed from the tree, the root node will no longer
+  cast it to a string.
+* Adds node type iterators to the container class (e.g. `eachComment`).
+* Adds filter function to the container class.
+* Adds split function to the container class.
+* Create new node types by doing `parser.id(opts)` etc.
+* Adds support for pseudo classes anywhere in the selector.
+
+# 0.0.3
+
+* Adds `next` and `prev` to the node class.
+* Adds `first` and `last` getters to the container class.
+* Adds `every` and `some` iterators to the container class.
+* Add `empty` alias for `removeAll`.
+* Combinators are now types of node.
+* Fixes the at method so that it is not an alias for `index`.
+* Tidy up creation of new nodes in the parser.
+* Refactors how namespaces are handled for consistency & less redundant code.
+* Refactors AST to use `nodes` exclusively, and eliminates excessive nesting.
+* Fixes nested pseudo parsing.
+* Fixes whitespace parsing.
+
+# 0.0.2
+
+* Adds support for namespace selectors.
+* Adds support for selectors joined by escaped spaces - such as `.\31\ 0`.
+
+# 0.0.1
+
+* Initial release.
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/LICENSE-MIT b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/LICENSE-MIT
new file mode 100644
index 0000000000000000000000000000000000000000..fd0e863a614fbcfc11bcfd0836975d1f5bfeb191
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/LICENSE-MIT
@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/README.md b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..18a01c5c89df6f34d31f37e24b67e1155aedcfe0
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/README.md
@@ -0,0 +1,49 @@
+# postcss-selector-parser [![Build Status](https://travis-ci.org/postcss/postcss-selector-parser.svg?branch=master)](https://travis-ci.org/postcss/postcss-selector-parser)
+
+> Selector parser with built in methods for working with selector strings.
+
+## Install
+
+With [npm](https://npmjs.com/package/postcss-selector-parser) do:
+
+```
+npm install postcss-selector-parser
+```
+
+## Quick Start
+
+```js
+const parser = require('postcss-selector-parser');
+const transform = selectors => {
+    selectors.walk(selector => {
+        // do something with the selector
+        console.log(String(selector))
+    });
+};
+
+const transformed = parser(transform).processSync('h1, h2, h3');
+```
+
+To normalize selector whitespace:
+
+```js
+const parser = require('postcss-selector-parser');
+const normalized = parser().processSync('h1, h2, h3', {lossless: false});
+// -> h1,h2,h3
+```
+
+Async support is provided through `parser.process` and will resolve a Promise
+with the resulting selector string.
+
+## API
+
+Please see [API.md](API.md).
+
+## Credits
+
+* Huge thanks to Andrey Sitnik (@ai) for work on PostCSS which helped
+  accelerate this module's development.
+
+## License
+
+MIT
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/index.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..01f453b7ec3cb73fbc7effb22169a9de050aaf3c
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/index.js
@@ -0,0 +1,26 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _processor = require('./processor');
+
+var _processor2 = _interopRequireDefault(_processor);
+
+var _selectors = require('./selectors');
+
+var selectors = _interopRequireWildcard(_selectors);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parser = function parser(processor) {
+  return new _processor2.default(processor);
+};
+
+Object.assign(parser, selectors);
+
+delete parser.__esModule;
+
+exports.default = parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/parser.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/parser.js
new file mode 100644
index 0000000000000000000000000000000000000000..798faade4a11227a755bb5e4747552e3bc60f5c3
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/parser.js
@@ -0,0 +1,1088 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _WHITESPACE_TOKENS, _extends2;
+
+var _indexesOf = require('indexes-of');
+
+var _indexesOf2 = _interopRequireDefault(_indexesOf);
+
+var _uniq = require('uniq');
+
+var _uniq2 = _interopRequireDefault(_uniq);
+
+var _root = require('./selectors/root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selectors/selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _className = require('./selectors/className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _comment = require('./selectors/comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./selectors/id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _tag = require('./selectors/tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _string = require('./selectors/string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _pseudo = require('./selectors/pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _attribute = require('./selectors/attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _universal = require('./selectors/universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+var _combinator = require('./selectors/combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _nesting = require('./selectors/nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _sortAscending = require('./sortAscending');
+
+var _sortAscending2 = _interopRequireDefault(_sortAscending);
+
+var _tokenize = require('./tokenize');
+
+var _tokenize2 = _interopRequireDefault(_tokenize);
+
+var _tokenTypes = require('./tokenTypes');
+
+var tokens = _interopRequireWildcard(_tokenTypes);
+
+var _types = require('./selectors/types');
+
+var types = _interopRequireWildcard(_types);
+
+var _util = require('./util');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+
+var WHITESPACE_EQUIV_TOKENS = _extends({}, WHITESPACE_TOKENS, (_extends2 = {}, _extends2[tokens.comment] = true, _extends2));
+
+function tokenStart(token) {
+    return {
+        line: token[_tokenize.FIELDS.START_LINE],
+        column: token[_tokenize.FIELDS.START_COL]
+    };
+}
+
+function tokenEnd(token) {
+    return {
+        line: token[_tokenize.FIELDS.END_LINE],
+        column: token[_tokenize.FIELDS.END_COL]
+    };
+}
+
+function getSource(startLine, startColumn, endLine, endColumn) {
+    return {
+        start: {
+            line: startLine,
+            column: startColumn
+        },
+        end: {
+            line: endLine,
+            column: endColumn
+        }
+    };
+}
+
+function getTokenSource(token) {
+    return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+}
+
+function getTokenSourceSpan(startToken, endToken) {
+    if (!startToken) {
+        return undefined;
+    }
+    return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+}
+
+function unescapeProp(node, prop) {
+    var value = node[prop];
+    if (typeof value !== "string") {
+        return;
+    }
+    if (value.indexOf("\\") !== -1) {
+        (0, _util.ensureObject)(node, 'raws');
+        node[prop] = (0, _util.unesc)(value);
+        if (node.raws[prop] === undefined) {
+            node.raws[prop] = value;
+        }
+    }
+    return node;
+}
+
+var Parser = function () {
+    function Parser(rule) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        _classCallCheck(this, Parser);
+
+        this.rule = rule;
+        this.options = Object.assign({ lossy: false, safe: false }, options);
+        this.position = 0;
+
+        this.css = typeof this.rule === 'string' ? this.rule : this.rule.selector;
+
+        this.tokens = (0, _tokenize2.default)({
+            css: this.css,
+            error: this._errorGenerator(),
+            safe: this.options.safe
+        });
+
+        var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+        this.root = new _root2.default({ source: rootSource });
+        this.root.errorGenerator = this._errorGenerator();
+
+        var selector = new _selector2.default({ source: { start: { line: 1, column: 1 } } });
+        this.root.append(selector);
+        this.current = selector;
+
+        this.loop();
+    }
+
+    Parser.prototype._errorGenerator = function _errorGenerator() {
+        var _this = this;
+
+        return function (message, errorOptions) {
+            if (typeof _this.rule === 'string') {
+                return new Error(message);
+            }
+            return _this.rule.error(message, errorOptions);
+        };
+    };
+
+    Parser.prototype.attribute = function attribute() {
+        var attr = [];
+        var startingToken = this.currToken;
+        this.position++;
+        while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+            attr.push(this.currToken);
+            this.position++;
+        }
+        if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+            return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+
+        var len = attr.length;
+        var node = {
+            source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+            sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+        };
+
+        if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
+            return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
+        }
+
+        var pos = 0;
+        var spaceBefore = '';
+        var commentBefore = '';
+        var lastAdded = null;
+        var spaceAfterMeaningfulToken = false;
+
+        while (pos < len) {
+            var token = attr[pos];
+            var content = this.content(token);
+            var next = attr[pos + 1];
+
+            switch (token[_tokenize.FIELDS.TYPE]) {
+                case tokens.space:
+                    // if (
+                    //     len === 1 ||
+                    //     pos === 0 && this.content(next) === '|'
+                    // ) {
+                    //     return this.expected('attribute', token[TOKEN.START_POS], content);
+                    // }
+                    spaceAfterMeaningfulToken = true;
+                    if (this.options.lossy) {
+                        break;
+                    }
+                    if (lastAdded) {
+                        (0, _util.ensureObject)(node, 'spaces', lastAdded);
+                        var prevContent = node.spaces[lastAdded].after || '';
+                        node.spaces[lastAdded].after = prevContent + content;
+
+                        var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
+
+                        if (existingComment) {
+                            node.raws.spaces[lastAdded].after = existingComment + content;
+                        }
+                    } else {
+                        spaceBefore = spaceBefore + content;
+                        commentBefore = commentBefore + content;
+                    }
+                    break;
+                case tokens.asterisk:
+                    if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                        node.operator = content;
+                        lastAdded = 'operator';
+                    } else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+                        if (spaceBefore) {
+                            (0, _util.ensureObject)(node, 'spaces', 'attribute');
+                            node.spaces.attribute.before = spaceBefore;
+                            spaceBefore = '';
+                        }
+                        if (commentBefore) {
+                            (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+                            node.raws.spaces.attribute.before = spaceBefore;
+                            commentBefore = '';
+                        }
+                        node.namespace = (node.namespace || "") + content;
+                        var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
+                        if (rawValue) {
+                            node.raws.namespace += content;
+                        }
+                        lastAdded = 'namespace';
+                    }
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.dollar:
+                    if (lastAdded === "value") {
+                        var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
+                        node.value += "$";
+                        if (oldRawValue) {
+                            node.raws.value = oldRawValue + "$";
+                        }
+                        break;
+                    }
+                // Falls through
+                case tokens.caret:
+                    if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                        node.operator = content;
+                        lastAdded = 'operator';
+                    }
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.combinator:
+                    if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                        node.operator = content;
+                        lastAdded = 'operator';
+                    }
+                    if (content !== '|') {
+                        spaceAfterMeaningfulToken = false;
+                        break;
+                    }
+                    if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                        node.operator = content;
+                        lastAdded = 'operator';
+                    } else if (!node.namespace && !node.attribute) {
+                        node.namespace = true;
+                    }
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.word:
+                    if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved.
+                    !node.operator && !node.namespace) {
+                        node.namespace = content;
+                        lastAdded = 'namespace';
+                    } else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+                        if (spaceBefore) {
+                            (0, _util.ensureObject)(node, 'spaces', 'attribute');
+                            node.spaces.attribute.before = spaceBefore;
+
+                            spaceBefore = '';
+                        }
+                        if (commentBefore) {
+                            (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+                            node.raws.spaces.attribute.before = commentBefore;
+                            commentBefore = '';
+                        }
+                        node.attribute = (node.attribute || "") + content;
+                        var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
+                        if (_rawValue) {
+                            node.raws.attribute += content;
+                        }
+                        lastAdded = 'attribute';
+                    } else if (!node.value || lastAdded === "value" && !spaceAfterMeaningfulToken) {
+                        var _unescaped = (0, _util.unesc)(content);
+                        var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
+                        var oldValue = node.value || '';
+                        node.value = oldValue + _unescaped;
+                        node.quoteMark = null;
+                        if (_unescaped !== content || _oldRawValue) {
+                            (0, _util.ensureObject)(node, 'raws');
+                            node.raws.value = (_oldRawValue || oldValue) + content;
+                        }
+                        lastAdded = 'value';
+                    } else {
+                        var insensitive = content === 'i' || content === "I";
+                        if (node.value && (node.quoteMark || spaceAfterMeaningfulToken)) {
+                            node.insensitive = insensitive;
+                            if (!insensitive || content === "I") {
+                                (0, _util.ensureObject)(node, 'raws');
+                                node.raws.insensitiveFlag = content;
+                            }
+                            lastAdded = 'insensitive';
+                            if (spaceBefore) {
+                                (0, _util.ensureObject)(node, 'spaces', 'insensitive');
+                                node.spaces.insensitive.before = spaceBefore;
+
+                                spaceBefore = '';
+                            }
+                            if (commentBefore) {
+                                (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
+                                node.raws.spaces.insensitive.before = commentBefore;
+                                commentBefore = '';
+                            }
+                        } else if (node.value) {
+                            lastAdded = 'value';
+                            node.value += content;
+                            if (node.raws.value) {
+                                node.raws.value += content;
+                            }
+                        }
+                    }
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.str:
+                    if (!node.attribute || !node.operator) {
+                        return this.error('Expected an attribute followed by an operator preceding the string.', {
+                            index: token[_tokenize.FIELDS.START_POS]
+                        });
+                    }
+
+                    var _unescapeValue = (0, _attribute.unescapeValue)(content),
+                        unescaped = _unescapeValue.unescaped,
+                        quoteMark = _unescapeValue.quoteMark;
+
+                    node.value = unescaped;
+                    node.quoteMark = quoteMark;
+                    lastAdded = 'value';
+
+                    (0, _util.ensureObject)(node, 'raws');
+                    node.raws.value = content;
+
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.equals:
+                    if (!node.attribute) {
+                        return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
+                    }
+                    if (node.value) {
+                        return this.error('Unexpected "=" found; an operator was already defined.', { index: token[_tokenize.FIELDS.START_POS] });
+                    }
+                    node.operator = node.operator ? node.operator + content : content;
+                    lastAdded = 'operator';
+                    spaceAfterMeaningfulToken = false;
+                    break;
+                case tokens.comment:
+                    if (lastAdded) {
+                        if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === 'insensitive') {
+                            var lastComment = (0, _util.getProp)(node, 'spaces', lastAdded, 'after') || '';
+                            var rawLastComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || lastComment;
+
+                            (0, _util.ensureObject)(node, 'raws', 'spaces', lastAdded);
+                            node.raws.spaces[lastAdded].after = rawLastComment + content;
+                        } else {
+                            var lastValue = node[lastAdded] || '';
+                            var rawLastValue = (0, _util.getProp)(node, 'raws', lastAdded) || lastValue;
+                            (0, _util.ensureObject)(node, 'raws');
+                            node.raws[lastAdded] = rawLastValue + content;
+                        }
+                    } else {
+                        commentBefore = commentBefore + content;
+                    }
+                    break;
+                default:
+                    return this.error('Unexpected "' + content + '" found.', { index: token[_tokenize.FIELDS.START_POS] });
+            }
+            pos++;
+        }
+        unescapeProp(node, "attribute");
+        unescapeProp(node, "namespace");
+        this.newNode(new _attribute2.default(node));
+        this.position++;
+    };
+
+    /**
+     * return a node containing meaningless garbage up to (but not including) the specified token position.
+     * if the token position is negative, all remaining tokens are consumed.
+     *
+     * This returns an array containing a single string node if all whitespace,
+     * otherwise an array of comment nodes with space before and after.
+     *
+     * These tokens are not added to the current selector, the caller can add them or use them to amend
+     * a previous node's space metadata.
+     *
+     * In lossy mode, this returns only comments.
+     */
+
+
+    Parser.prototype.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+        if (stopPosition < 0) {
+            stopPosition = this.tokens.length;
+        }
+        var startPosition = this.position;
+        var nodes = [];
+        var space = "";
+        var lastComment = undefined;
+        do {
+            if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+                if (!this.options.lossy) {
+                    space += this.content();
+                }
+            } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+                var spaces = {};
+                if (space) {
+                    spaces.before = space;
+                    space = "";
+                }
+                lastComment = new _comment2.default({
+                    value: this.content(),
+                    source: getTokenSource(this.currToken),
+                    sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+                    spaces: spaces
+                });
+                nodes.push(lastComment);
+            }
+        } while (++this.position < stopPosition);
+
+        if (space) {
+            if (lastComment) {
+                lastComment.spaces.after = space;
+            } else if (!this.options.lossy) {
+                var firstToken = this.tokens[startPosition];
+                var lastToken = this.tokens[this.position - 1];
+                nodes.push(new _string2.default({
+                    value: '',
+                    source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+                    sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+                    spaces: { before: space, after: '' }
+                }));
+            }
+        }
+        return nodes;
+    };
+
+    /**
+     * 
+     * @param {*} nodes 
+     */
+
+
+    Parser.prototype.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes) {
+        var _this2 = this;
+
+        var requiredSpace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+        var space = "";
+        var rawSpace = "";
+        nodes.forEach(function (n) {
+            var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+            var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+            space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+            rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+        });
+        if (rawSpace === space) {
+            rawSpace = undefined;
+        }
+        var result = { space: space, rawSpace: rawSpace };
+        return result;
+    };
+
+    Parser.prototype.isNamedCombinator = function isNamedCombinator() {
+        var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.position;
+
+        return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+    };
+
+    Parser.prototype.namedCombinator = function namedCombinator() {
+        if (this.isNamedCombinator()) {
+            var nameRaw = this.content(this.tokens[this.position + 1]);
+            var name = (0, _util.unesc)(nameRaw).toLowerCase();
+            var raws = {};
+            if (name !== nameRaw) {
+                raws.value = '/' + nameRaw + '/';
+            }
+            var node = new _combinator2.default({
+                value: '/' + name + '/',
+                source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+                sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+                raws: raws
+            });
+            this.position = this.position + 3;
+            return node;
+        } else {
+            this.unexpected();
+        }
+    };
+
+    Parser.prototype.combinator = function combinator() {
+        var _this3 = this;
+
+        if (this.content() === '|') {
+            return this.namespace();
+        }
+        // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
+        var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+
+        if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+            var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+            if (nodes.length > 0) {
+                var last = this.current.last;
+                if (last) {
+                    var _convertWhitespaceNod = this.convertWhitespaceNodesToSpace(nodes),
+                        space = _convertWhitespaceNod.space,
+                        rawSpace = _convertWhitespaceNod.rawSpace;
+
+                    if (rawSpace !== undefined) {
+                        last.rawSpaceAfter += rawSpace;
+                    }
+                    last.spaces.after += space;
+                } else {
+                    nodes.forEach(function (n) {
+                        return _this3.newNode(n);
+                    });
+                }
+            }
+            return;
+        }
+
+        var firstToken = this.currToken;
+        var spaceOrDescendantSelectorNodes = undefined;
+        if (nextSigTokenPos > this.position) {
+            spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+        }
+
+        var node = void 0;
+        if (this.isNamedCombinator()) {
+            node = this.namedCombinator();
+        } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+            node = new _combinator2.default({
+                value: this.content(),
+                source: getTokenSource(this.currToken),
+                sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+            });
+            this.position++;
+        } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+            // pass
+        } else if (!spaceOrDescendantSelectorNodes) {
+            this.unexpected();
+        }
+
+        if (node) {
+            if (spaceOrDescendantSelectorNodes) {
+                var _convertWhitespaceNod2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
+                    _space = _convertWhitespaceNod2.space,
+                    _rawSpace = _convertWhitespaceNod2.rawSpace;
+
+                node.spaces.before = _space;
+                node.rawSpaceBefore = _rawSpace;
+            }
+        } else {
+            // descendant combinator
+            var _convertWhitespaceNod3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
+                _space2 = _convertWhitespaceNod3.space,
+                _rawSpace2 = _convertWhitespaceNod3.rawSpace;
+
+            if (!_rawSpace2) {
+                _rawSpace2 = _space2;
+            }
+            var spaces = {};
+            var raws = { spaces: {} };
+            if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
+                spaces.before = _space2.slice(0, _space2.length - 1);
+                raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+            } else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) {
+                spaces.after = _space2.slice(1);
+                raws.spaces.after = _rawSpace2.slice(1);
+            } else {
+                raws.value = _rawSpace2;
+            }
+            node = new _combinator2.default({
+                value: ' ',
+                source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+                sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+                spaces: spaces,
+                raws: raws
+            });
+        }
+
+        if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+            node.spaces.after = this.optionalSpace(this.content());
+            this.position++;
+        }
+
+        return this.newNode(node);
+    };
+
+    Parser.prototype.comma = function comma() {
+        if (this.position === this.tokens.length - 1) {
+            this.root.trailingComma = true;
+            this.position++;
+            return;
+        }
+        this.current._inferEndPosition();
+        var selector = new _selector2.default({ source: { start: tokenStart(this.tokens[this.position + 1]) } });
+        this.current.parent.append(selector);
+        this.current = selector;
+        this.position++;
+    };
+
+    Parser.prototype.comment = function comment() {
+        var current = this.currToken;
+        this.newNode(new _comment2.default({
+            value: this.content(),
+            source: getTokenSource(current),
+            sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.error = function error(message, opts) {
+        throw this.root.error(message, opts);
+    };
+
+    Parser.prototype.missingBackslash = function missingBackslash() {
+        return this.error('Expected a backslash preceding the semicolon.', {
+            index: this.currToken[_tokenize.FIELDS.START_POS]
+        });
+    };
+
+    Parser.prototype.missingParenthesis = function missingParenthesis() {
+        return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+    };
+
+    Parser.prototype.missingSquareBracket = function missingSquareBracket() {
+        return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+    };
+
+    Parser.prototype.unexpected = function unexpected() {
+        return this.error('Unexpected \'' + this.content() + '\'. Escaping special characters with \\ may help.', this.currToken[_tokenize.FIELDS.START_POS]);
+    };
+
+    Parser.prototype.namespace = function namespace() {
+        var before = this.prevToken && this.content(this.prevToken) || true;
+        if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+            this.position++;
+            return this.word(before);
+        } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+            this.position++;
+            return this.universal(before);
+        }
+    };
+
+    Parser.prototype.nesting = function nesting() {
+        if (this.nextToken) {
+            var nextContent = this.content(this.nextToken);
+            if (nextContent === "|") {
+                this.position++;
+                return;
+            }
+        }
+        var current = this.currToken;
+        this.newNode(new _nesting2.default({
+            value: this.content(),
+            source: getTokenSource(current),
+            sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.parentheses = function parentheses() {
+        var last = this.current.last;
+        var unbalanced = 1;
+        this.position++;
+        if (last && last.type === types.PSEUDO) {
+            var selector = new _selector2.default({ source: { start: tokenStart(this.tokens[this.position - 1]) } });
+            var cache = this.current;
+            last.append(selector);
+            this.current = selector;
+            while (this.position < this.tokens.length && unbalanced) {
+                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+                    unbalanced++;
+                }
+                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+                    unbalanced--;
+                }
+                if (unbalanced) {
+                    this.parse();
+                } else {
+                    this.current.source.end = tokenEnd(this.currToken);
+                    this.current.parent.source.end = tokenEnd(this.currToken);
+                    this.position++;
+                }
+            }
+            this.current = cache;
+        } else {
+            // I think this case should be an error. It's used to implement a basic parse of media queries
+            // but I don't think it's a good idea.
+            var parenStart = this.currToken;
+            var parenValue = "(";
+            var parenEnd = void 0;
+            while (this.position < this.tokens.length && unbalanced) {
+                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+                    unbalanced++;
+                }
+                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+                    unbalanced--;
+                }
+                parenEnd = this.currToken;
+                parenValue += this.parseParenthesisToken(this.currToken);
+                this.position++;
+            }
+            if (last) {
+                last.appendToPropertyAndEscape("value", parenValue, parenValue);
+            } else {
+                this.newNode(new _string2.default({
+                    value: parenValue,
+                    source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+                    sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+                }));
+            }
+        }
+        if (unbalanced) {
+            return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+    };
+
+    Parser.prototype.pseudo = function pseudo() {
+        var _this4 = this;
+
+        var pseudoStr = '';
+        var startingToken = this.currToken;
+        while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+            pseudoStr += this.content();
+            this.position++;
+        }
+        if (!this.currToken) {
+            return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
+        }
+        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+            this.splitWord(false, function (first, length) {
+                pseudoStr += first;
+                _this4.newNode(new _pseudo2.default({
+                    value: pseudoStr,
+                    source: getTokenSourceSpan(startingToken, _this4.currToken),
+                    sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+                }));
+                if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+                    _this4.error('Misplaced parenthesis.', {
+                        index: _this4.nextToken[_tokenize.FIELDS.START_POS]
+                    });
+                }
+            });
+        } else {
+            return this.expected(['pseudo-class', 'pseudo-element'], this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+    };
+
+    Parser.prototype.space = function space() {
+        var content = this.content();
+        // Handle space before and after the selector
+        if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+            this.spaces = this.optionalSpace(content);
+            this.position++;
+        } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+            this.current.last.spaces.after = this.optionalSpace(content);
+            this.position++;
+        } else {
+            this.combinator();
+        }
+    };
+
+    Parser.prototype.string = function string() {
+        var current = this.currToken;
+        this.newNode(new _string2.default({
+            value: this.content(),
+            source: getTokenSource(current),
+            sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.universal = function universal(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && this.content(nextToken) === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        var current = this.currToken;
+        this.newNode(new _universal2.default({
+            value: this.content(),
+            source: getTokenSource(current),
+            sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }), namespace);
+        this.position++;
+    };
+
+    Parser.prototype.splitWord = function splitWord(namespace, firstCallback) {
+        var _this5 = this;
+
+        var nextToken = this.nextToken;
+        var word = this.content();
+        while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+            this.position++;
+            var current = this.content();
+            word += current;
+            if (current.lastIndexOf('\\') === current.length - 1) {
+                var next = this.nextToken;
+                if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+                    word += this.requiredSpace(this.content(next));
+                    this.position++;
+                }
+            }
+            nextToken = this.nextToken;
+        }
+        var hasClass = (0, _indexesOf2.default)(word, '.').filter(function (i) {
+            return word[i - 1] !== '\\';
+        });
+        var hasId = (0, _indexesOf2.default)(word, '#');
+        // Eliminate Sass interpolations from the list of id indexes
+        var interpolations = (0, _indexesOf2.default)(word, '#{');
+        if (interpolations.length) {
+            hasId = hasId.filter(function (hashIndex) {
+                return !~interpolations.indexOf(hashIndex);
+            });
+        }
+        var indices = (0, _sortAscending2.default)((0, _uniq2.default)([0].concat(hasClass, hasId)));
+        indices.forEach(function (ind, i) {
+            var index = indices[i + 1] || word.length;
+            var value = word.slice(ind, index);
+            if (i === 0 && firstCallback) {
+                return firstCallback.call(_this5, value, indices.length);
+            }
+            var node = void 0;
+            var current = _this5.currToken;
+            var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
+            var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
+            if (~hasClass.indexOf(ind)) {
+                var classNameOpts = {
+                    value: value.slice(1),
+                    source: source,
+                    sourceIndex: sourceIndex
+                };
+                node = new _className2.default(unescapeProp(classNameOpts, "value"));
+            } else if (~hasId.indexOf(ind)) {
+                var idOpts = {
+                    value: value.slice(1),
+                    source: source,
+                    sourceIndex: sourceIndex
+                };
+                node = new _id2.default(unescapeProp(idOpts, "value"));
+            } else {
+                var tagOpts = {
+                    value: value,
+                    source: source,
+                    sourceIndex: sourceIndex
+                };
+                unescapeProp(tagOpts, "value");
+                node = new _tag2.default(tagOpts);
+            }
+            _this5.newNode(node, namespace);
+            // Ensure that the namespace is used only once
+            namespace = null;
+        });
+        this.position++;
+    };
+
+    Parser.prototype.word = function word(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && this.content(nextToken) === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        return this.splitWord(namespace);
+    };
+
+    Parser.prototype.loop = function loop() {
+        while (this.position < this.tokens.length) {
+            this.parse(true);
+        }
+        this.current._inferEndPosition();
+        return this.root;
+    };
+
+    Parser.prototype.parse = function parse(throwOnParenthesis) {
+        switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+            case tokens.space:
+                this.space();
+                break;
+            case tokens.comment:
+                this.comment();
+                break;
+            case tokens.openParenthesis:
+                this.parentheses();
+                break;
+            case tokens.closeParenthesis:
+                if (throwOnParenthesis) {
+                    this.missingParenthesis();
+                }
+                break;
+            case tokens.openSquare:
+                this.attribute();
+                break;
+            case tokens.dollar:
+            case tokens.caret:
+            case tokens.equals:
+            case tokens.word:
+                this.word();
+                break;
+            case tokens.colon:
+                this.pseudo();
+                break;
+            case tokens.comma:
+                this.comma();
+                break;
+            case tokens.asterisk:
+                this.universal();
+                break;
+            case tokens.ampersand:
+                this.nesting();
+                break;
+            case tokens.slash:
+            case tokens.combinator:
+                this.combinator();
+                break;
+            case tokens.str:
+                this.string();
+                break;
+            // These cases throw; no break needed.
+            case tokens.closeSquare:
+                this.missingSquareBracket();
+            case tokens.semicolon:
+                this.missingBackslash();
+            default:
+                this.unexpected();
+        }
+    };
+
+    /**
+     * Helpers
+     */
+
+    Parser.prototype.expected = function expected(description, index, found) {
+        if (Array.isArray(description)) {
+            var last = description.pop();
+            description = description.join(', ') + ' or ' + last;
+        }
+        var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
+        if (!found) {
+            return this.error('Expected ' + an + ' ' + description + '.', { index: index });
+        }
+        return this.error('Expected ' + an + ' ' + description + ', found "' + found + '" instead.', { index: index });
+    };
+
+    Parser.prototype.requiredSpace = function requiredSpace(space) {
+        return this.options.lossy ? ' ' : space;
+    };
+
+    Parser.prototype.optionalSpace = function optionalSpace(space) {
+        return this.options.lossy ? '' : space;
+    };
+
+    Parser.prototype.lossySpace = function lossySpace(space, required) {
+        if (this.options.lossy) {
+            return required ? ' ' : '';
+        } else {
+            return space;
+        }
+    };
+
+    Parser.prototype.parseParenthesisToken = function parseParenthesisToken(token) {
+        var content = this.content(token);
+        if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
+            return this.requiredSpace(content);
+        } else {
+            return content;
+        }
+    };
+
+    Parser.prototype.newNode = function newNode(node, namespace) {
+        if (namespace) {
+            if (/^ +$/.test(namespace)) {
+                if (!this.options.lossy) {
+                    this.spaces = (this.spaces || '') + namespace;
+                }
+                namespace = true;
+            }
+            node.namespace = namespace;
+            unescapeProp(node, "namespace");
+        }
+        if (this.spaces) {
+            node.spaces.before = this.spaces;
+            this.spaces = '';
+        }
+        return this.current.append(node);
+    };
+
+    Parser.prototype.content = function content() {
+        var token = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.currToken;
+
+        return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+    };
+
+    /**
+     * returns the index of the next non-whitespace, non-comment token.
+     * returns -1 if no meaningful token is found.
+     */
+    Parser.prototype.locateNextMeaningfulToken = function locateNextMeaningfulToken() {
+        var startPosition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.position + 1;
+
+        var searchPosition = startPosition;
+        while (searchPosition < this.tokens.length) {
+            if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+                searchPosition++;
+                continue;
+            } else {
+                return searchPosition;
+            }
+        }
+        return -1;
+    };
+
+    _createClass(Parser, [{
+        key: 'currToken',
+        get: function get() {
+            return this.tokens[this.position];
+        }
+    }, {
+        key: 'nextToken',
+        get: function get() {
+            return this.tokens[this.position + 1];
+        }
+    }, {
+        key: 'prevToken',
+        get: function get() {
+            return this.tokens[this.position - 1];
+        }
+    }]);
+
+    return Parser;
+}();
+
+exports.default = Parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/processor.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/processor.js
new file mode 100644
index 0000000000000000000000000000000000000000..0bc061d63cd9392381fb83a2dc9f88cadbfdcca5
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/processor.js
@@ -0,0 +1,185 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _parser = require("./parser");
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Processor = function () {
+    function Processor(func, options) {
+        _classCallCheck(this, Processor);
+
+        this.func = func || function noop() {};
+        this.funcRes = null;
+        this.options = options;
+    }
+
+    Processor.prototype._shouldUpdateSelector = function _shouldUpdateSelector(rule) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var merged = Object.assign({}, this.options, options);
+        if (merged.updateSelector === false) {
+            return false;
+        } else {
+            return typeof rule !== "string";
+        }
+    };
+
+    Processor.prototype._isLossy = function _isLossy() {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var merged = Object.assign({}, this.options, options);
+        if (merged.lossless === false) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+
+    Processor.prototype._root = function _root(rule) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var parser = new _parser2.default(rule, this._parseOptions(options));
+        return parser.root;
+    };
+
+    Processor.prototype._parseOptions = function _parseOptions(options) {
+        return {
+            lossy: this._isLossy(options)
+        };
+    };
+
+    Processor.prototype._run = function _run(rule) {
+        var _this = this;
+
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        return new Promise(function (resolve, reject) {
+            try {
+                var root = _this._root(rule, options);
+                Promise.resolve(_this.func(root)).then(function (transform) {
+                    var string = undefined;
+                    if (_this._shouldUpdateSelector(rule, options)) {
+                        string = root.toString();
+                        rule.selector = string;
+                    }
+                    return { transform: transform, root: root, string: string };
+                }).then(resolve, reject);
+            } catch (e) {
+                reject(e);
+                return;
+            }
+        });
+    };
+
+    Processor.prototype._runSync = function _runSync(rule) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var root = this._root(rule, options);
+        var transform = this.func(root);
+        if (transform && typeof transform.then === "function") {
+            throw new Error("Selector processor returned a promise to a synchronous call.");
+        }
+        var string = undefined;
+        if (options.updateSelector && typeof rule !== "string") {
+            string = root.toString();
+            rule.selector = string;
+        }
+        return { transform: transform, root: root, string: string };
+    };
+
+    /**
+     * Process rule into a selector AST.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {Promise<parser.Root>} The AST of the selector after processing it.
+     */
+
+
+    Processor.prototype.ast = function ast(rule, options) {
+        return this._run(rule, options).then(function (result) {
+            return result.root;
+        });
+    };
+
+    /**
+     * Process rule into a selector AST synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {parser.Root} The AST of the selector after processing it.
+     */
+
+
+    Processor.prototype.astSync = function astSync(rule, options) {
+        return this._runSync(rule, options).root;
+    };
+
+    /**
+     * Process a selector into a transformed value asynchronously
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {Promise<any>} The value returned by the processor.
+     */
+
+
+    Processor.prototype.transform = function transform(rule, options) {
+        return this._run(rule, options).then(function (result) {
+            return result.transform;
+        });
+    };
+
+    /**
+     * Process a selector into a transformed value synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {any} The value returned by the processor.
+     */
+
+
+    Processor.prototype.transformSync = function transformSync(rule, options) {
+        return this._runSync(rule, options).transform;
+    };
+
+    /**
+     * Process a selector into a new selector string asynchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {string} the selector after processing.
+     */
+
+
+    Processor.prototype.process = function process(rule, options) {
+        return this._run(rule, options).then(function (result) {
+            return result.string || result.root.toString();
+        });
+    };
+
+    /**
+     * Process a selector into a new selector string synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {string} the selector after processing.
+     */
+
+
+    Processor.prototype.processSync = function processSync(rule, options) {
+        var result = this._runSync(rule, options);
+        return result.string || result.root.toString();
+    };
+
+    return Processor;
+}();
+
+exports.default = Processor;
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/attribute.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/attribute.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2b7d390109de9cd0a75b35cc66e023fd32a9c7f
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/attribute.js
@@ -0,0 +1,468 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _CSSESC_QUOTE_OPTIONS;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+exports.unescapeValue = unescapeValue;
+
+var _cssesc = require("cssesc");
+
+var _cssesc2 = _interopRequireDefault(_cssesc);
+
+var _unesc = require("../util/unesc");
+
+var _unesc2 = _interopRequireDefault(_unesc);
+
+var _namespace = require("./namespace");
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require("./types");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var _require = require("util"),
+    deprecate = _require.deprecate;
+
+var WRAPPED_IN_QUOTES = /^('|")(.*)\1$/;
+
+var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
+
+var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+
+var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+
+function unescapeValue(value) {
+    var deprecatedUsage = false;
+    var quoteMark = null;
+    var unescaped = value;
+    var m = unescaped.match(WRAPPED_IN_QUOTES);
+    if (m) {
+        quoteMark = m[1];
+        unescaped = m[2];
+    }
+    unescaped = (0, _unesc2.default)(unescaped);
+    if (unescaped !== value) {
+        deprecatedUsage = true;
+    }
+    return {
+        deprecatedUsage: deprecatedUsage,
+        unescaped: unescaped,
+        quoteMark: quoteMark
+    };
+}
+
+function handleDeprecatedContructorOpts(opts) {
+    if (opts.quoteMark !== undefined) {
+        return opts;
+    }
+    if (opts.value === undefined) {
+        return opts;
+    }
+    warnOfDeprecatedConstructor();
+
+    var _unescapeValue = unescapeValue(opts.value),
+        quoteMark = _unescapeValue.quoteMark,
+        unescaped = _unescapeValue.unescaped;
+
+    if (!opts.raws) {
+        opts.raws = {};
+    }
+    if (opts.raws.value === undefined) {
+        opts.raws.value = opts.value;
+    }
+    opts.value = unescaped;
+    opts.quoteMark = quoteMark;
+    return opts;
+}
+
+var Attribute = function (_Namespace) {
+    _inherits(Attribute, _Namespace);
+
+    function Attribute() {
+        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        _classCallCheck(this, Attribute);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, handleDeprecatedContructorOpts(opts)));
+
+        _this.type = _types.ATTRIBUTE;
+        _this.raws = _this.raws || {};
+        Object.defineProperty(_this.raws, 'unquoted', {
+            get: deprecate(function () {
+                return _this.value;
+            }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+            set: deprecate(function () {
+                return _this.value;
+            }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+        });
+        _this._constructed = true;
+        return _this;
+    }
+
+    /**
+     * Returns the Attribute's value quoted such that it would be legal to use
+     * in the value of a css file. The original value's quotation setting
+     * used for stringification is left unchanged. See `setValue(value, options)`
+     * if you want to control the quote settings of a new value for the attribute.
+     *
+     * You can also change the quotation used for the current value by setting quoteMark.
+     *
+     * Options:
+     *   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+     *     option is not set, the original value for quoteMark will be used. If
+     *     indeterminate, a double quote is used. The legal values are:
+     *     * `null` - the value will be unquoted and characters will be escaped as necessary.
+     *     * `'` - the value will be quoted with a single quote and single quotes are escaped.
+     *     * `"` - the value will be quoted with a double quote and double quotes are escaped.
+     *   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+     *     over the quoteMark option value.
+     *   * smart {boolean} - if true, will select a quote mark based on the value
+     *     and the other options specified here. See the `smartQuoteMark()`
+     *     method.
+     **/
+
+
+    Attribute.prototype.getQuotedValue = function getQuotedValue() {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var quoteMark = this._determineQuoteMark(options);
+        var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
+        var escaped = (0, _cssesc2.default)(this._value, cssescopts);
+        return escaped;
+    };
+
+    Attribute.prototype._determineQuoteMark = function _determineQuoteMark(options) {
+        return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+    };
+
+    /**
+     * Set the unescaped value with the specified quotation options. The value
+     * provided must not include any wrapping quote marks -- those quotes will
+     * be interpreted as part of the value and escaped accordingly.
+     */
+
+
+    Attribute.prototype.setValue = function setValue(value) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        this._value = value;
+        this._quoteMark = this._determineQuoteMark(options);
+        this._syncRawValue();
+    };
+
+    /**
+     * Intelligently select a quoteMark value based on the value's contents. If
+     * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+     * mark will be picked that minimizes the number of escapes.
+     *
+     * If there's no clear winner, the quote mark from these options is used,
+     * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+     * true). If the quoteMark is unspecified, a double quote is used.
+     *
+     * @param options This takes the quoteMark and preferCurrentQuoteMark options
+     * from the quoteValue method.
+     */
+
+
+    Attribute.prototype.smartQuoteMark = function smartQuoteMark(options) {
+        var v = this.value;
+        var numSingleQuotes = v.replace(/[^']/g, '').length;
+        var numDoubleQuotes = v.replace(/[^"]/g, '').length;
+        if (numSingleQuotes + numDoubleQuotes === 0) {
+            var escaped = (0, _cssesc2.default)(v, { isIdentifier: true });
+            if (escaped === v) {
+                return Attribute.NO_QUOTE;
+            } else {
+                var pref = this.preferredQuoteMark(options);
+                if (pref === Attribute.NO_QUOTE) {
+                    // pick a quote mark that isn't none and see if it's smaller
+                    var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+                    var opts = CSSESC_QUOTE_OPTIONS[quote];
+                    var quoteValue = (0, _cssesc2.default)(v, opts);
+                    if (quoteValue.length < escaped.length) {
+                        return quote;
+                    }
+                }
+                return pref;
+            }
+        } else if (numDoubleQuotes === numSingleQuotes) {
+            return this.preferredQuoteMark(options);
+        } else if (numDoubleQuotes < numSingleQuotes) {
+            return Attribute.DOUBLE_QUOTE;
+        } else {
+            return Attribute.SINGLE_QUOTE;
+        }
+    };
+
+    /**
+     * Selects the preferred quote mark based on the options and the current quote mark value.
+     * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+     * instead.
+     */
+
+
+    Attribute.prototype.preferredQuoteMark = function preferredQuoteMark(options) {
+        var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+
+        if (quoteMark === undefined) {
+            quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+        }
+
+        if (quoteMark === undefined) {
+            quoteMark = Attribute.DOUBLE_QUOTE;
+        }
+
+        return quoteMark;
+    };
+
+    Attribute.prototype._syncRawValue = function _syncRawValue() {
+        var rawValue = (0, _cssesc2.default)(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+        if (rawValue === this._value) {
+            if (this.raws) {
+                delete this.raws.value;
+            }
+        } else {
+            this.raws.value = rawValue;
+        }
+    };
+
+    Attribute.prototype._handleEscapes = function _handleEscapes(prop, value) {
+        if (this._constructed) {
+            var escaped = (0, _cssesc2.default)(value, { isIdentifier: true });
+            if (escaped !== value) {
+                this.raws[prop] = escaped;
+            } else {
+                delete this.raws[prop];
+            }
+        }
+    };
+
+    Attribute.prototype._spacesFor = function _spacesFor(name) {
+        var attrSpaces = { before: '', after: '' };
+        var spaces = this.spaces[name] || {};
+        var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+        return Object.assign(attrSpaces, spaces, rawSpaces);
+    };
+
+    Attribute.prototype._stringFor = function _stringFor(name) {
+        var spaceName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : name;
+        var concat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultAttrConcat;
+
+        var attrSpaces = this._spacesFor(spaceName);
+        return concat(this.stringifyProperty(name), attrSpaces);
+    };
+
+    /**
+     * returns the offset of the attribute part specified relative to the
+     * start of the node of the output string.
+     *
+     * * "ns" - alias for "namespace"
+     * * "namespace" - the namespace if it exists.
+     * * "attribute" - the attribute name
+     * * "attributeNS" - the start of the attribute or its namespace
+     * * "operator" - the match operator of the attribute
+     * * "value" - The value (string or identifier)
+     * * "insensitive" - the case insensitivity flag;
+     * @param part One of the possible values inside an attribute.
+     * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+     */
+
+
+    Attribute.prototype.offsetOf = function offsetOf(name) {
+        var count = 1;
+        var attributeSpaces = this._spacesFor("attribute");
+        count += attributeSpaces.before.length;
+        if (name === "namespace" || name === "ns") {
+            return this.namespace ? count : -1;
+        }
+        if (name === "attributeNS") {
+            return count;
+        }
+
+        count += this.namespaceString.length;
+        if (this.namespace) {
+            count += 1;
+        }
+        if (name === "attribute") {
+            return count;
+        }
+
+        count += this.stringifyProperty("attribute").length;
+        count += attributeSpaces.after.length;
+        var operatorSpaces = this._spacesFor("operator");
+        count += operatorSpaces.before.length;
+        var operator = this.stringifyProperty("operator");
+        if (name === "operator") {
+            return operator ? count : -1;
+        }
+
+        count += operator.length;
+        count += operatorSpaces.after.length;
+        var valueSpaces = this._spacesFor("value");
+        count += valueSpaces.before.length;
+        var value = this.stringifyProperty("value");
+        if (name === "value") {
+            return value ? count : -1;
+        }
+
+        count += value.length;
+        count += valueSpaces.after.length;
+        var insensitiveSpaces = this._spacesFor("insensitive");
+        count += insensitiveSpaces.before.length;
+        if (name === "insensitive") {
+            return this.insensitive ? count : -1;
+        }
+        return -1;
+    };
+
+    Attribute.prototype.toString = function toString() {
+        var _this2 = this;
+
+        var selector = [this.rawSpaceBefore, '['];
+
+        selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
+
+        if (this.operator && this.value) {
+            selector.push(this._stringFor('operator'));
+            selector.push(this._stringFor('value'));
+            selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) {
+                if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
+                    attrSpaces.before = " ";
+                }
+                return defaultAttrConcat(attrValue, attrSpaces);
+            }));
+        }
+
+        selector.push(']');
+        selector.push(this.rawSpaceAfter);
+        return selector.join('');
+    };
+
+    _createClass(Attribute, [{
+        key: "quoted",
+        get: function get() {
+            var qm = this.quoteMark;
+            return qm === "'" || qm === '"';
+        },
+        set: function set(value) {
+            warnOfDeprecatedQuotedAssignment();
+        }
+
+        /**
+         * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+         * returns `null` if the value is not quoted.
+         * returns `undefined` if the quotation state is unknown (this can happen when
+         * the attribute is constructed without specifying a quote mark.)
+         */
+
+    }, {
+        key: "quoteMark",
+        get: function get() {
+            return this._quoteMark;
+        }
+
+        /**
+         * Set the quote mark to be used by this attribute's value.
+         * If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
+         * value is updated accordingly.
+         *
+         * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
+         */
+        ,
+        set: function set(quoteMark) {
+            if (!this._constructed) {
+                this._quoteMark = quoteMark;
+                return;
+            }
+            if (this._quoteMark !== quoteMark) {
+                this._quoteMark = quoteMark;
+                this._syncRawValue();
+            }
+        }
+    }, {
+        key: "qualifiedAttribute",
+        get: function get() {
+            return this.qualifiedName(this.raws.attribute || this.attribute);
+        }
+    }, {
+        key: "insensitiveFlag",
+        get: function get() {
+            return this.insensitive ? 'i' : '';
+        }
+    }, {
+        key: "value",
+        get: function get() {
+            return this._value;
+        }
+
+        /**
+         * Before 3.0, the value had to be set to an escaped value including any wrapped
+         * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+         * is unescaped during parsing and any quote marks are removed.
+         *
+         * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+         * a deprecation warning is raised when the new value contains any characters that would
+         * require escaping (including if it contains wrapped quotes).
+         *
+         * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+         * how the new value is quoted.
+         */
+        ,
+        set: function set(v) {
+            if (this._constructed) {
+                var _unescapeValue2 = unescapeValue(v),
+                    deprecatedUsage = _unescapeValue2.deprecatedUsage,
+                    unescaped = _unescapeValue2.unescaped,
+                    quoteMark = _unescapeValue2.quoteMark;
+
+                if (deprecatedUsage) {
+                    warnOfDeprecatedValueAssignment();
+                }
+                if (unescaped === this._value && quoteMark === this._quoteMark) {
+                    return;
+                }
+                this._value = unescaped;
+                this._quoteMark = quoteMark;
+                this._syncRawValue();
+            } else {
+                this._value = v;
+            }
+        }
+    }, {
+        key: "attribute",
+        get: function get() {
+            return this._attribute;
+        },
+        set: function set(name) {
+            this._handleEscapes("attribute", name);
+            this._attribute = name;
+        }
+    }]);
+
+    return Attribute;
+}(_namespace2.default);
+
+Attribute.NO_QUOTE = null;
+Attribute.SINGLE_QUOTE = "'";
+Attribute.DOUBLE_QUOTE = '"';
+exports.default = Attribute;
+
+
+var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+    "'": { quotes: 'single', wrap: true },
+    '"': { quotes: 'double', wrap: true }
+}, _CSSESC_QUOTE_OPTIONS[null] = { isIdentifier: true }, _CSSESC_QUOTE_OPTIONS);
+
+function defaultAttrConcat(attrValue, attrSpaces) {
+    return "" + attrSpaces.before + attrValue + attrSpaces.after;
+}
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/className.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/className.js
new file mode 100644
index 0000000000000000000000000000000000000000..03299ee27fc0050a2a6d2c3d90cfc9113118a80f
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/className.js
@@ -0,0 +1,67 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _cssesc = require('cssesc');
+
+var _cssesc2 = _interopRequireDefault(_cssesc);
+
+var _util = require('../util');
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ClassName = function (_Node) {
+    _inherits(ClassName, _Node);
+
+    function ClassName(opts) {
+        _classCallCheck(this, ClassName);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.CLASS;
+        _this._constructed = true;
+        return _this;
+    }
+
+    ClassName.prototype.toString = function toString() {
+        return [this.rawSpaceBefore, String('.' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+    };
+
+    _createClass(ClassName, [{
+        key: 'value',
+        set: function set(v) {
+            if (this._constructed) {
+                var escaped = (0, _cssesc2.default)(v, { isIdentifier: true });
+                if (escaped !== v) {
+                    (0, _util.ensureObject)(this, "raws");
+                    this.raws.value = escaped;
+                } else if (this.raws) {
+                    delete this.raws.value;
+                }
+            }
+            this._value = v;
+        },
+        get: function get() {
+            return this._value;
+        }
+    }]);
+
+    return ClassName;
+}(_node2.default);
+
+exports.default = ClassName;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/combinator.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/combinator.js
new file mode 100644
index 0000000000000000000000000000000000000000..673dc7501a8507278d2a7ee9a0109538c01a97f2
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/combinator.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Combinator = function (_Node) {
+    _inherits(Combinator, _Node);
+
+    function Combinator(opts) {
+        _classCallCheck(this, Combinator);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMBINATOR;
+        return _this;
+    }
+
+    return Combinator;
+}(_node2.default);
+
+exports.default = Combinator;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/comment.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/comment.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d96556e0de6cacf4ffba73144f48e7e7c5515cb
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/comment.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Comment = function (_Node) {
+    _inherits(Comment, _Node);
+
+    function Comment(opts) {
+        _classCallCheck(this, Comment);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMMENT;
+        return _this;
+    }
+
+    return Comment;
+}(_node2.default);
+
+exports.default = Comment;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/constructors.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/constructors.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf6ad8211ca8d847b3626e9abc42eb7a7187a78b
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/constructors.js
@@ -0,0 +1,91 @@
+'use strict';
+
+exports.__esModule = true;
+exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = undefined;
+
+var _attribute = require('./attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _className = require('./className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _combinator = require('./combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _comment = require('./comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _nesting = require('./nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _pseudo = require('./pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _root = require('./root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _string = require('./string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _tag = require('./tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _universal = require('./universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var attribute = exports.attribute = function attribute(opts) {
+  return new _attribute2.default(opts);
+};
+var className = exports.className = function className(opts) {
+  return new _className2.default(opts);
+};
+var combinator = exports.combinator = function combinator(opts) {
+  return new _combinator2.default(opts);
+};
+var comment = exports.comment = function comment(opts) {
+  return new _comment2.default(opts);
+};
+var id = exports.id = function id(opts) {
+  return new _id2.default(opts);
+};
+var nesting = exports.nesting = function nesting(opts) {
+  return new _nesting2.default(opts);
+};
+var pseudo = exports.pseudo = function pseudo(opts) {
+  return new _pseudo2.default(opts);
+};
+var root = exports.root = function root(opts) {
+  return new _root2.default(opts);
+};
+var selector = exports.selector = function selector(opts) {
+  return new _selector2.default(opts);
+};
+var string = exports.string = function string(opts) {
+  return new _string2.default(opts);
+};
+var tag = exports.tag = function tag(opts) {
+  return new _tag2.default(opts);
+};
+var universal = exports.universal = function universal(opts) {
+  return new _universal2.default(opts);
+};
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/container.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/container.js
new file mode 100644
index 0000000000000000000000000000000000000000..552fc5244f4f25088f4151332e1408e378ab575b
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/container.js
@@ -0,0 +1,392 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Container = function (_Node) {
+    _inherits(Container, _Node);
+
+    function Container(opts) {
+        _classCallCheck(this, Container);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        if (!_this.nodes) {
+            _this.nodes = [];
+        }
+        return _this;
+    }
+
+    Container.prototype.append = function append(selector) {
+        selector.parent = this;
+        this.nodes.push(selector);
+        return this;
+    };
+
+    Container.prototype.prepend = function prepend(selector) {
+        selector.parent = this;
+        this.nodes.unshift(selector);
+        return this;
+    };
+
+    Container.prototype.at = function at(index) {
+        return this.nodes[index];
+    };
+
+    Container.prototype.index = function index(child) {
+        if (typeof child === 'number') {
+            return child;
+        }
+        return this.nodes.indexOf(child);
+    };
+
+    Container.prototype.removeChild = function removeChild(child) {
+        child = this.index(child);
+        this.at(child).parent = undefined;
+        this.nodes.splice(child, 1);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (index >= child) {
+                this.indexes[id] = index - 1;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.removeAll = function removeAll() {
+        for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+                if (_i >= _iterator.length) break;
+                _ref = _iterator[_i++];
+            } else {
+                _i = _iterator.next();
+                if (_i.done) break;
+                _ref = _i.value;
+            }
+
+            var node = _ref;
+
+            node.parent = undefined;
+        }
+        this.nodes = [];
+        return this;
+    };
+
+    Container.prototype.empty = function empty() {
+        return this.removeAll();
+    };
+
+    Container.prototype.insertAfter = function insertAfter(oldNode, newNode) {
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex + 1, 0, newNode);
+
+        newNode.parent = this;
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex <= index) {
+                this.indexes[id] = index + 1;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.insertBefore = function insertBefore(oldNode, newNode) {
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex, 0, newNode);
+
+        newNode.parent = this;
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (index <= oldIndex) {
+                this.indexes[id] = index + 1;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype._findChildAtPosition = function _findChildAtPosition(line, col) {
+        var found = undefined;
+        this.each(function (node) {
+            if (node.atPosition) {
+                var foundChild = node.atPosition(line, col);
+                if (foundChild) {
+                    found = foundChild;
+                    return false;
+                }
+            } else if (node.isAtPosition(line, col)) {
+                found = node;
+                return false;
+            }
+        });
+        return found;
+    };
+
+    /**
+     * Return the most specific node at the line and column number given.
+     * The source location is based on the original parsed location, locations aren't
+     * updated as selector nodes are mutated.
+     * 
+     * Note that this location is relative to the location of the first character
+     * of the selector, and not the location of the selector in the overall document
+     * when used in conjunction with postcss.
+     *
+     * If not found, returns undefined.
+     * @param {number} line The line number of the node to find. (1-based index)
+     * @param {number} col  The column number of the node to find. (1-based index)
+     */
+
+
+    Container.prototype.atPosition = function atPosition(line, col) {
+        if (this.isAtPosition(line, col)) {
+            return this._findChildAtPosition(line, col) || this;
+        } else {
+            return undefined;
+        }
+    };
+
+    Container.prototype._inferEndPosition = function _inferEndPosition() {
+        if (this.last && this.last.source && this.last.source.end) {
+            this.source = this.source || {};
+            this.source.end = this.source.end || {};
+            Object.assign(this.source.end, this.last.source.end);
+        }
+    };
+
+    Container.prototype.each = function each(callback) {
+        if (!this.lastEach) {
+            this.lastEach = 0;
+        }
+        if (!this.indexes) {
+            this.indexes = {};
+        }
+
+        this.lastEach++;
+        var id = this.lastEach;
+        this.indexes[id] = 0;
+
+        if (!this.length) {
+            return undefined;
+        }
+
+        var index = void 0,
+            result = void 0;
+        while (this.indexes[id] < this.length) {
+            index = this.indexes[id];
+            result = callback(this.at(index), index);
+            if (result === false) {
+                break;
+            }
+
+            this.indexes[id] += 1;
+        }
+
+        delete this.indexes[id];
+
+        if (result === false) {
+            return false;
+        }
+    };
+
+    Container.prototype.walk = function walk(callback) {
+        return this.each(function (node, i) {
+            var result = callback(node, i);
+
+            if (result !== false && node.length) {
+                result = node.walk(callback);
+            }
+
+            if (result === false) {
+                return false;
+            }
+        });
+    };
+
+    Container.prototype.walkAttributes = function walkAttributes(callback) {
+        var _this2 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ATTRIBUTE) {
+                return callback.call(_this2, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkClasses = function walkClasses(callback) {
+        var _this3 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.CLASS) {
+                return callback.call(_this3, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkCombinators = function walkCombinators(callback) {
+        var _this4 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMBINATOR) {
+                return callback.call(_this4, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkComments = function walkComments(callback) {
+        var _this5 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMMENT) {
+                return callback.call(_this5, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkIds = function walkIds(callback) {
+        var _this6 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ID) {
+                return callback.call(_this6, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkNesting = function walkNesting(callback) {
+        var _this7 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.NESTING) {
+                return callback.call(_this7, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkPseudos = function walkPseudos(callback) {
+        var _this8 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.PSEUDO) {
+                return callback.call(_this8, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkTags = function walkTags(callback) {
+        var _this9 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.TAG) {
+                return callback.call(_this9, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkUniversals = function walkUniversals(callback) {
+        var _this10 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.UNIVERSAL) {
+                return callback.call(_this10, selector);
+            }
+        });
+    };
+
+    Container.prototype.split = function split(callback) {
+        var _this11 = this;
+
+        var current = [];
+        return this.reduce(function (memo, node, index) {
+            var split = callback.call(_this11, node);
+            current.push(node);
+            if (split) {
+                memo.push(current);
+                current = [];
+            } else if (index === _this11.length - 1) {
+                memo.push(current);
+            }
+            return memo;
+        }, []);
+    };
+
+    Container.prototype.map = function map(callback) {
+        return this.nodes.map(callback);
+    };
+
+    Container.prototype.reduce = function reduce(callback, memo) {
+        return this.nodes.reduce(callback, memo);
+    };
+
+    Container.prototype.every = function every(callback) {
+        return this.nodes.every(callback);
+    };
+
+    Container.prototype.some = function some(callback) {
+        return this.nodes.some(callback);
+    };
+
+    Container.prototype.filter = function filter(callback) {
+        return this.nodes.filter(callback);
+    };
+
+    Container.prototype.sort = function sort(callback) {
+        return this.nodes.sort(callback);
+    };
+
+    Container.prototype.toString = function toString() {
+        return this.map(String).join('');
+    };
+
+    _createClass(Container, [{
+        key: 'first',
+        get: function get() {
+            return this.at(0);
+        }
+    }, {
+        key: 'last',
+        get: function get() {
+            return this.at(this.length - 1);
+        }
+    }, {
+        key: 'length',
+        get: function get() {
+            return this.nodes.length;
+        }
+    }]);
+
+    return Container;
+}(_node2.default);
+
+exports.default = Container;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/guards.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/guards.js
new file mode 100644
index 0000000000000000000000000000000000000000..3dcb7edd88d2894376ff48e4145d40dd4d2f2c69
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/guards.js
@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = exports.isPseudo = exports.isNesting = exports.isIdentifier = exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = undefined;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var _IS_TYPE;
+
+exports.isNode = isNode;
+exports.isPseudoElement = isPseudoElement;
+exports.isPseudoClass = isPseudoClass;
+exports.isContainer = isContainer;
+exports.isNamespace = isNamespace;
+
+var _types = require("./types");
+
+var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
+
+function isNode(node) {
+    return (typeof node === "undefined" ? "undefined" : _typeof(node)) === "object" && IS_TYPE[node.type];
+}
+
+function isNodeType(type, node) {
+    return isNode(node) && node.type === type;
+}
+
+var isAttribute = exports.isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
+var isClassName = exports.isClassName = isNodeType.bind(null, _types.CLASS);
+var isCombinator = exports.isCombinator = isNodeType.bind(null, _types.COMBINATOR);
+var isComment = exports.isComment = isNodeType.bind(null, _types.COMMENT);
+var isIdentifier = exports.isIdentifier = isNodeType.bind(null, _types.ID);
+var isNesting = exports.isNesting = isNodeType.bind(null, _types.NESTING);
+var isPseudo = exports.isPseudo = isNodeType.bind(null, _types.PSEUDO);
+var isRoot = exports.isRoot = isNodeType.bind(null, _types.ROOT);
+var isSelector = exports.isSelector = isNodeType.bind(null, _types.SELECTOR);
+var isString = exports.isString = isNodeType.bind(null, _types.STRING);
+var isTag = exports.isTag = isNodeType.bind(null, _types.TAG);
+var isUniversal = exports.isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
+
+function isPseudoElement(node) {
+    return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value === ":before" || node.value === ":after");
+}
+function isPseudoClass(node) {
+    return isPseudo(node) && !isPseudoElement(node);
+}
+
+function isContainer(node) {
+    return !!(isNode(node) && node.walk);
+}
+
+function isNamespace(node) {
+    return isAttribute(node) || isTag(node);
+}
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/id.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ce4238668d0cae4e06e16335582e15531d58877
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/id.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ID = function (_Node) {
+    _inherits(ID, _Node);
+
+    function ID(opts) {
+        _classCallCheck(this, ID);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.ID;
+        return _this;
+    }
+
+    ID.prototype.toString = function toString() {
+        return [this.rawSpaceBefore, String('#' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+    };
+
+    return ID;
+}(_node2.default);
+
+exports.default = ID;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/index.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..f999e14242c3de92c59f2714af75b0a4c6b17ecc
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/index.js
@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+
+var _constructors = require("./constructors");
+
+Object.keys(_constructors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constructors[key];
+    }
+  });
+});
+
+var _guards = require("./guards");
+
+Object.keys(_guards).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _guards[key];
+    }
+  });
+});
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/namespace.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/namespace.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4d2486947ebc22bfbfd70817e28cb38e4bda187
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/namespace.js
@@ -0,0 +1,98 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _cssesc = require('cssesc');
+
+var _cssesc2 = _interopRequireDefault(_cssesc);
+
+var _util = require('../util');
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Namespace = function (_Node) {
+    _inherits(Namespace, _Node);
+
+    function Namespace() {
+        _classCallCheck(this, Namespace);
+
+        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
+    }
+
+    Namespace.prototype.qualifiedName = function qualifiedName(value) {
+        if (this.namespace) {
+            return this.namespaceString + '|' + value;
+        } else {
+            return value;
+        }
+    };
+
+    Namespace.prototype.toString = function toString() {
+        return [this.rawSpaceBefore, this.qualifiedName(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+    };
+
+    _createClass(Namespace, [{
+        key: 'namespace',
+        get: function get() {
+            return this._namespace;
+        },
+        set: function set(namespace) {
+            if (namespace === true || namespace === "*" || namespace === "&") {
+                this._namespace = namespace;
+                if (this.raws) {
+                    delete this.raws.namespace;
+                }
+                return;
+            }
+
+            var escaped = (0, _cssesc2.default)(namespace, { isIdentifier: true });
+            this._namespace = namespace;
+            if (escaped !== namespace) {
+                (0, _util.ensureObject)(this, "raws");
+                this.raws.namespace = escaped;
+            } else if (this.raws) {
+                delete this.raws.namespace;
+            }
+        }
+    }, {
+        key: 'ns',
+        get: function get() {
+            return this._namespace;
+        },
+        set: function set(namespace) {
+            this.namespace = namespace;
+        }
+    }, {
+        key: 'namespaceString',
+        get: function get() {
+            if (this.namespace) {
+                var ns = this.stringifyProperty("namespace");
+                if (ns === true) {
+                    return '';
+                } else {
+                    return ns;
+                }
+            } else {
+                return '';
+            }
+        }
+    }]);
+
+    return Namespace;
+}(_node2.default);
+
+exports.default = Namespace;
+;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/nesting.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/nesting.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3264b07bdb04f5bf097025ccdccc2647e47c561
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/nesting.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Nesting = function (_Node) {
+    _inherits(Nesting, _Node);
+
+    function Nesting(opts) {
+        _classCallCheck(this, Nesting);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.NESTING;
+        _this.value = '&';
+        return _this;
+    }
+
+    return Nesting;
+}(_node2.default);
+
+exports.default = Nesting;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/node.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/node.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ae66121c853e138a37e21dba6f84a258e9c8a29
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/node.js
@@ -0,0 +1,216 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var _util = require('../util');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var cloneNode = function cloneNode(obj, parent) {
+    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj === null) {
+        return obj;
+    }
+
+    var cloned = new obj.constructor();
+
+    for (var i in obj) {
+        if (!obj.hasOwnProperty(i)) {
+            continue;
+        }
+        var value = obj[i];
+        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
+
+        if (i === 'parent' && type === 'object') {
+            if (parent) {
+                cloned[i] = parent;
+            }
+        } else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) {
+                return cloneNode(j, cloned);
+            });
+        } else {
+            cloned[i] = cloneNode(value, cloned);
+        }
+    }
+
+    return cloned;
+};
+
+var Node = function () {
+    function Node() {
+        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        _classCallCheck(this, Node);
+
+        Object.assign(this, opts);
+        this.spaces = this.spaces || {};
+        this.spaces.before = this.spaces.before || '';
+        this.spaces.after = this.spaces.after || '';
+    }
+
+    Node.prototype.remove = function remove() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.parent = undefined;
+        return this;
+    };
+
+    Node.prototype.replaceWith = function replaceWith() {
+        if (this.parent) {
+            for (var index in arguments) {
+                this.parent.insertBefore(this, arguments[index]);
+            }
+            this.remove();
+        }
+        return this;
+    };
+
+    Node.prototype.next = function next() {
+        return this.parent.at(this.parent.index(this) + 1);
+    };
+
+    Node.prototype.prev = function prev() {
+        return this.parent.at(this.parent.index(this) - 1);
+    };
+
+    Node.prototype.clone = function clone() {
+        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var cloned = cloneNode(this);
+        for (var name in overrides) {
+            cloned[name] = overrides[name];
+        }
+        return cloned;
+    };
+
+    /**
+     * Some non-standard syntax doesn't follow normal escaping rules for css.
+     * This allows non standard syntax to be appended to an existing property
+     * by specifying the escaped value. By specifying the escaped value,
+     * illegal characters are allowed to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped optional. the escaped value of the property.
+     */
+
+
+    Node.prototype.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+        if (!this.raws) {
+            this.raws = {};
+        }
+        var originalValue = this[name];
+        var originalEscaped = this.raws[name];
+        this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
+        if (originalEscaped || valueEscaped !== value) {
+            this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+        } else {
+            delete this.raws[name]; // delete any escaped value that was created by the setter.
+        }
+    };
+
+    /**
+     * Some non-standard syntax doesn't follow normal escaping rules for css.
+     * This allows the escaped value to be specified directly, allowing illegal
+     * characters to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped the escaped value of the property.
+     */
+
+
+    Node.prototype.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+        if (!this.raws) {
+            this.raws = {};
+        }
+        this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+        this.raws[name] = valueEscaped;
+    };
+
+    /**
+     * When you want a value to passed through to CSS directly. This method
+     * deletes the corresponding raw value causing the stringifier to fallback
+     * to the unescaped value.
+     * @param {string} name the property to set.
+     * @param {any} value The value that is both escaped and unescaped.
+     */
+
+
+    Node.prototype.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+        this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+        if (this.raws) {
+            delete this.raws[name];
+        }
+    };
+
+    /**
+     * 
+     * @param {number} line The number (starting with 1)
+     * @param {number} column The column number (starting with 1)
+     */
+
+
+    Node.prototype.isAtPosition = function isAtPosition(line, column) {
+        if (this.source && this.source.start && this.source.end) {
+            if (this.source.start.line > line) {
+                return false;
+            }
+            if (this.source.end.line < line) {
+                return false;
+            }
+            if (this.source.start.line === line && this.source.start.column > column) {
+                return false;
+            }
+            if (this.source.end.line === line && this.source.end.column < column) {
+                return false;
+            }
+            return true;
+        }
+        return undefined;
+    };
+
+    Node.prototype.stringifyProperty = function stringifyProperty(name) {
+        return this.raws && this.raws[name] || this[name];
+    };
+
+    Node.prototype.toString = function toString() {
+        return [this.rawSpaceBefore, String(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+    };
+
+    _createClass(Node, [{
+        key: 'rawSpaceBefore',
+        get: function get() {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces && this.spaces.before;
+            }
+            return rawSpace || "";
+        },
+        set: function set(raw) {
+            (0, _util.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.before = raw;
+        }
+    }, {
+        key: 'rawSpaceAfter',
+        get: function get() {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces.after;
+            }
+            return rawSpace || "";
+        },
+        set: function set(raw) {
+            (0, _util.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.after = raw;
+        }
+    }]);
+
+    return Node;
+}();
+
+exports.default = Node;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/pseudo.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d97f4f9d0d1c874f8d2099fdfcbe66b159ceab2
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
@@ -0,0 +1,40 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Pseudo = function (_Container) {
+    _inherits(Pseudo, _Container);
+
+    function Pseudo(opts) {
+        _classCallCheck(this, Pseudo);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.PSEUDO;
+        return _this;
+    }
+
+    Pseudo.prototype.toString = function toString() {
+        var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
+        return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
+    };
+
+    return Pseudo;
+}(_container2.default);
+
+exports.default = Pseudo;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/root.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/root.js
new file mode 100644
index 0000000000000000000000000000000000000000..96a9ad5f73aad464fa89695661d2df0dfb6a6b37
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/root.js
@@ -0,0 +1,60 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Root = function (_Container) {
+    _inherits(Root, _Container);
+
+    function Root(opts) {
+        _classCallCheck(this, Root);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.ROOT;
+        return _this;
+    }
+
+    Root.prototype.toString = function toString() {
+        var str = this.reduce(function (memo, selector) {
+            memo.push(String(selector));
+            return memo;
+        }, []).join(',');
+        return this.trailingComma ? str + ',' : str;
+    };
+
+    Root.prototype.error = function error(message, options) {
+        if (this._error) {
+            return this._error(message, options);
+        } else {
+            return new Error(message);
+        }
+    };
+
+    _createClass(Root, [{
+        key: 'errorGenerator',
+        set: function set(handler) {
+            this._error = handler;
+        }
+    }]);
+
+    return Root;
+}(_container2.default);
+
+exports.default = Root;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/selector.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/selector.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2187662f204a875283183ae4e3c52b503b12fc1
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/selector.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Selector = function (_Container) {
+    _inherits(Selector, _Container);
+
+    function Selector(opts) {
+        _classCallCheck(this, Selector);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.SELECTOR;
+        return _this;
+    }
+
+    return Selector;
+}(_container2.default);
+
+exports.default = Selector;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/string.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/string.js
new file mode 100644
index 0000000000000000000000000000000000000000..d644e7d1a350e1b3632446e33ccc3295307f1b1c
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/string.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var String = function (_Node) {
+    _inherits(String, _Node);
+
+    function String(opts) {
+        _classCallCheck(this, String);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.STRING;
+        return _this;
+    }
+
+    return String;
+}(_node2.default);
+
+exports.default = String;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/tag.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/tag.js
new file mode 100644
index 0000000000000000000000000000000000000000..a1f2848a2100e481b5b145afe10df9fccf761223
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/tag.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Tag = function (_Namespace) {
+    _inherits(Tag, _Namespace);
+
+    function Tag(opts) {
+        _classCallCheck(this, Tag);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.TAG;
+        return _this;
+    }
+
+    return Tag;
+}(_namespace2.default);
+
+exports.default = Tag;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/types.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/types.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa73ac9ada44dfa4725dfea4977842c777ae9947
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/types.js
@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+var TAG = exports.TAG = 'tag';
+var STRING = exports.STRING = 'string';
+var SELECTOR = exports.SELECTOR = 'selector';
+var ROOT = exports.ROOT = 'root';
+var PSEUDO = exports.PSEUDO = 'pseudo';
+var NESTING = exports.NESTING = 'nesting';
+var ID = exports.ID = 'id';
+var COMMENT = exports.COMMENT = 'comment';
+var COMBINATOR = exports.COMBINATOR = 'combinator';
+var CLASS = exports.CLASS = 'class';
+var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
+var UNIVERSAL = exports.UNIVERSAL = 'universal';
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/universal.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/universal.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4a35ff5dc8127952573bdb3d8a882087c5acff4
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/selectors/universal.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Universal = function (_Namespace) {
+    _inherits(Universal, _Namespace);
+
+    function Universal(opts) {
+        _classCallCheck(this, Universal);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.UNIVERSAL;
+        _this.value = '*';
+        return _this;
+    }
+
+    return Universal;
+}(_namespace2.default);
+
+exports.default = Universal;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/sortAscending.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/sortAscending.js
new file mode 100644
index 0000000000000000000000000000000000000000..17a2eb4e9fda1ca435ea22bba5050bc36c8e17b6
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/sortAscending.js
@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = sortAscending;
+function sortAscending(list) {
+    return list.sort(function (a, b) {
+        return a - b;
+    });
+};
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenTypes.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenTypes.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad885941a7f3f859c56fad372797ab4cb9696825
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenTypes.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+var ampersand = exports.ampersand = 38;
+var asterisk = exports.asterisk = 42;
+var at = exports.at = 64;
+var comma = exports.comma = 44;
+var colon = exports.colon = 58;
+var semicolon = exports.semicolon = 59;
+var openParenthesis = exports.openParenthesis = 40;
+var closeParenthesis = exports.closeParenthesis = 41;
+var openSquare = exports.openSquare = 91;
+var closeSquare = exports.closeSquare = 93;
+var dollar = exports.dollar = 36;
+var tilde = exports.tilde = 126;
+var caret = exports.caret = 94;
+var plus = exports.plus = 43;
+var equals = exports.equals = 61;
+var pipe = exports.pipe = 124;
+var greaterThan = exports.greaterThan = 62;
+var space = exports.space = 32;
+var singleQuote = exports.singleQuote = 39;
+var doubleQuote = exports.doubleQuote = 34;
+var slash = exports.slash = 47;
+var bang = exports.bang = 33;
+
+var backslash = exports.backslash = 92;
+var cr = exports.cr = 13;
+var feed = exports.feed = 12;
+var newline = exports.newline = 10;
+var tab = exports.tab = 9;
+
+// Expose aliases primarily for readability.
+var str = exports.str = singleQuote;
+
+// No good single character representation!
+var comment = exports.comment = -1;
+var word = exports.word = -2;
+var combinator = exports.combinator = -3;
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenize.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenize.js
new file mode 100644
index 0000000000000000000000000000000000000000..71c5e203200e44c775e2d15ab5a806f788e15ffc
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/tokenize.js
@@ -0,0 +1,271 @@
+'use strict';
+
+exports.__esModule = true;
+exports.FIELDS = undefined;
+
+var _unescapable, _wordDelimiters;
+
+exports.default = tokenize;
+
+var _tokenTypes = require('./tokenTypes');
+
+var t = _interopRequireWildcard(_tokenTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
+var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
+
+var hex = {};
+var hexChars = "0123456789abcdefABCDEF";
+for (var i = 0; i < hexChars.length; i++) {
+    hex[hexChars.charCodeAt(i)] = true;
+}
+
+/**
+ *  Returns the last index of the bar css word
+ * @param {string} css The string in which the word begins
+ * @param {number} start The index into the string where word's first letter occurs
+ */
+function consumeWord(css, start) {
+    var next = start;
+    var code = void 0;
+    do {
+        code = css.charCodeAt(next);
+        if (wordDelimiters[code]) {
+            return next - 1;
+        } else if (code === t.backslash) {
+            next = consumeEscape(css, next) + 1;
+        } else {
+            // All other characters are part of the word
+            next++;
+        }
+    } while (next < css.length);
+    return next - 1;
+}
+
+/**
+ *  Returns the last index of the escape sequence
+ * @param {string} css The string in which the sequence begins
+ * @param {number} start The index into the string where escape character (`\`) occurs.
+ */
+function consumeEscape(css, start) {
+    var next = start;
+    var code = css.charCodeAt(next + 1);
+    if (unescapable[code]) {
+        // just consume the escape char
+    } else if (hex[code]) {
+        var hexDigits = 0;
+        // consume up to 6 hex chars
+        do {
+            next++;
+            hexDigits++;
+            code = css.charCodeAt(next + 1);
+        } while (hex[code] && hexDigits < 6);
+        // if fewer than 6 hex chars, a trailing space ends the escape
+        if (hexDigits < 6 && code === t.space) {
+            next++;
+        }
+    } else {
+        // the next char is part of the current word
+        next++;
+    }
+    return next;
+}
+
+var FIELDS = exports.FIELDS = {
+    TYPE: 0,
+    START_LINE: 1,
+    START_COL: 2,
+    END_LINE: 3,
+    END_COL: 4,
+    START_POS: 5,
+    END_POS: 6
+};
+
+function tokenize(input) {
+    var tokens = [];
+    var css = input.css.valueOf();
+    var _css = css,
+        length = _css.length;
+
+    var offset = -1;
+    var line = 1;
+    var start = 0;
+    var end = 0;
+
+    var code = void 0,
+        content = void 0,
+        endColumn = void 0,
+        endLine = void 0,
+        escaped = void 0,
+        escapePos = void 0,
+        last = void 0,
+        lines = void 0,
+        next = void 0,
+        nextLine = void 0,
+        nextOffset = void 0,
+        quote = void 0,
+        tokenType = void 0;
+
+    function unclosed(what, fix) {
+        if (input.safe) {
+            // fyi: this is never set to true.
+            css += fix;
+            next = css.length - 1;
+        } else {
+            throw input.error('Unclosed ' + what, line, start - offset, start);
+        }
+    }
+
+    while (start < length) {
+        code = css.charCodeAt(start);
+
+        if (code === t.newline) {
+            offset = start;
+            line += 1;
+        }
+
+        switch (code) {
+            case t.space:
+            case t.tab:
+            case t.newline:
+            case t.cr:
+            case t.feed:
+                next = start;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                    if (code === t.newline) {
+                        offset = next;
+                        line += 1;
+                    }
+                } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
+
+                tokenType = t.space;
+                endLine = line;
+                endColumn = next - offset - 1;
+                end = next;
+                break;
+
+            case t.plus:
+            case t.greaterThan:
+            case t.tilde:
+            case t.pipe:
+                next = start;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
+
+                tokenType = t.combinator;
+                endLine = line;
+                endColumn = start - offset;
+                end = next;
+                break;
+
+            // Consume these characters as single tokens.
+            case t.asterisk:
+            case t.ampersand:
+            case t.bang:
+            case t.comma:
+            case t.equals:
+            case t.dollar:
+            case t.caret:
+            case t.openSquare:
+            case t.closeSquare:
+            case t.colon:
+            case t.semicolon:
+            case t.openParenthesis:
+            case t.closeParenthesis:
+                next = start;
+                tokenType = code;
+                endLine = line;
+                endColumn = start - offset;
+                end = next + 1;
+                break;
+
+            case t.singleQuote:
+            case t.doubleQuote:
+                quote = code === t.singleQuote ? "'" : '"';
+                next = start;
+                do {
+                    escaped = false;
+                    next = css.indexOf(quote, next + 1);
+                    if (next === -1) {
+                        unclosed('quote', quote);
+                    }
+                    escapePos = next;
+                    while (css.charCodeAt(escapePos - 1) === t.backslash) {
+                        escapePos -= 1;
+                        escaped = !escaped;
+                    }
+                } while (escaped);
+
+                tokenType = t.str;
+                endLine = line;
+                endColumn = start - offset;
+                end = next + 1;
+                break;
+
+            default:
+                if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
+                    next = css.indexOf('*/', start + 2) + 1;
+                    if (next === 0) {
+                        unclosed('comment', '*/');
+                    }
+
+                    content = css.slice(start, next + 1);
+                    lines = content.split('\n');
+                    last = lines.length - 1;
+
+                    if (last > 0) {
+                        nextLine = line + last;
+                        nextOffset = next - lines[last].length;
+                    } else {
+                        nextLine = line;
+                        nextOffset = offset;
+                    }
+
+                    tokenType = t.comment;
+                    line = nextLine;
+                    endLine = nextLine;
+                    endColumn = next - nextOffset;
+                } else if (code === t.slash) {
+                    next = start;
+                    tokenType = code;
+                    endLine = line;
+                    endColumn = start - offset;
+                    end = next + 1;
+                } else {
+                    next = consumeWord(css, start);
+                    tokenType = t.word;
+                    endLine = line;
+                    endColumn = next - offset;
+                }
+
+                end = next + 1;
+                break;
+        }
+
+        // Ensure that the token structure remains consistent
+        tokens.push([tokenType, // [0] Token type
+        line, // [1] Starting line
+        start - offset, // [2] Starting column
+        endLine, // [3] Ending line
+        endColumn, // [4] Ending column
+        start, // [5] Start position / Source index
+        end] // [6] End position
+        );
+
+        // Reset offset for the next token
+        if (nextOffset) {
+            offset = nextOffset;
+            nextOffset = null;
+        }
+
+        start = end;
+    }
+
+    return tokens;
+}
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/ensureObject.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/ensureObject.js
new file mode 100644
index 0000000000000000000000000000000000000000..3fa62b3a80be6c1ba1ac98747d25c8fceb217d72
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/ensureObject.js
@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = ensureObject;
+function ensureObject(obj) {
+    for (var _len = arguments.length, props = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        props[_key - 1] = arguments[_key];
+    }
+
+    while (props.length > 0) {
+        var prop = props.shift();
+
+        if (!obj[prop]) {
+            obj[prop] = {};
+        }
+
+        obj = obj[prop];
+    }
+}
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/getProp.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/getProp.js
new file mode 100644
index 0000000000000000000000000000000000000000..2db333b59b7125ac9e4f263358e6c81effe898ba
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/getProp.js
@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getProp;
+function getProp(obj) {
+    for (var _len = arguments.length, props = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        props[_key - 1] = arguments[_key];
+    }
+
+    while (props.length > 0) {
+        var prop = props.shift();
+
+        if (!obj[prop]) {
+            return undefined;
+        }
+
+        obj = obj[prop];
+    }
+
+    return obj;
+}
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/index.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a453611ba34097d57957f3b5914f6b29bb0c3182
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/index.js
@@ -0,0 +1,41 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _unesc = require('./unesc');
+
+Object.defineProperty(exports, 'unesc', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_unesc).default;
+  }
+});
+
+var _getProp = require('./getProp');
+
+Object.defineProperty(exports, 'getProp', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getProp).default;
+  }
+});
+
+var _ensureObject = require('./ensureObject');
+
+Object.defineProperty(exports, 'ensureObject', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_ensureObject).default;
+  }
+});
+
+var _stripComments = require('./stripComments');
+
+Object.defineProperty(exports, 'stripComments', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_stripComments).default;
+  }
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/stripComments.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/stripComments.js
new file mode 100644
index 0000000000000000000000000000000000000000..40b41f9b827c8ab246aa55836dbc41426ef743a8
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/stripComments.js
@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = stripComments;
+function stripComments(str) {
+    var s = "";
+    var commentStart = str.indexOf("/*");
+    var lastEnd = 0;
+    while (commentStart >= 0) {
+        s = s + str.slice(lastEnd, commentStart);
+        var commentEnd = str.indexOf("*/", commentStart + 2);
+        if (commentEnd < 0) {
+            return s;
+        }
+        lastEnd = commentEnd + 2;
+        commentStart = str.indexOf("/*", lastEnd);
+    }
+    s = s + str.slice(lastEnd);
+    return s;
+}
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/unesc.js b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/unesc.js
new file mode 100644
index 0000000000000000000000000000000000000000..cdb03aca8825fedee4b7a67db16ecff9ae417903
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/dist/util/unesc.js
@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = unesc;
+var HEX_ESC = /\\(?:([0-9a-fA-F]{6})|([0-9a-fA-F]{1,5})(?: |(?![0-9a-fA-F])))/g;
+var OTHER_ESC = /\\(.)/g;
+function unesc(str) {
+    str = str.replace(HEX_ESC, function (_, hex1, hex2) {
+        var hex = hex1 || hex2;
+        var code = parseInt(hex, 16);
+        return String.fromCharCode(code);
+    });
+    str = str.replace(OTHER_ESC, function (_, char) {
+        return char;
+    });
+    return str;
+}
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/package.json b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a4bf86d4c918ddc8f7c9a0f287dbac588601f72
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/package.json
@@ -0,0 +1,76 @@
+{
+  "name": "postcss-selector-parser",
+  "version": "5.0.0",
+  "devDependencies": {
+    "ava": "^0.25.0",
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.3",
+    "babel-eslint": "^8.2.3",
+    "babel-plugin-add-module-exports": "^0.2.0",
+    "babel-plugin-precompile-charcodes": "^1.1.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-es2015-loose": "^7.0.0",
+    "babel-preset-stage-0": "^6.24.1",
+    "babel-register": "^6.26.0",
+    "coveralls": "^3.0.2",
+    "del-cli": "^1.1.0",
+    "eslint": "^4.19.1",
+    "eslint-plugin-babel": "^3.3.0",
+    "eslint-plugin-import": "^2.14.0",
+    "glob": "^7.1.3",
+    "minimist": "^1.2.0",
+    "nyc": "^11.7.3",
+    "postcss": "^7.0.7",
+    "semver": "^5.6.0"
+  },
+  "main": "dist/index.js",
+  "types": "postcss-selector-parser.d.ts",
+  "files": [
+    "API.md",
+    "CHANGELOG.md",
+    "LICENSE-MIT",
+    "dist",
+    "postcss-selector-parser.d.ts"
+  ],
+  "scripts": {
+    "pretest": "eslint src",
+    "prepare": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/",
+    "lintfix": "eslint --fix src",
+    "report": "nyc report --reporter=html",
+    "test": "nyc ava src/__tests__/*.js",
+    "testone": "ava"
+  },
+  "dependencies": {
+    "cssesc": "^2.0.0",
+    "indexes-of": "^1.0.1",
+    "uniq": "^1.0.1"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=4"
+  },
+  "homepage": "https://github.com/postcss/postcss-selector-parser",
+  "contributors": [
+    {
+      "name": "Ben Briggs",
+      "email": "beneb.info@gmail.com",
+      "url": "http://beneb.info"
+    },
+    {
+      "name": "Chris Eppstein",
+      "email": "chris@eppsteins.net",
+      "url": "http://twitter.com/chriseppstein"
+    }
+  ],
+  "repository": "postcss/postcss-selector-parser",
+  "ava": {
+    "require": "babel-register",
+    "concurrency": 5
+  },
+  "nyc": {
+    "exclude": [
+      "node_modules",
+      "**/__tests__"
+    ]
+  }
+}
diff --git a/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..52bdb7709db0b2caa72ec0b1de40f6dec6c1635d
--- /dev/null
+++ b/packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
@@ -0,0 +1,499 @@
+// Type definitions for postcss-selector-parser 2.2.3
+// Definitions by: Chris Eppstein <chris@eppsteins.net>
+
+/*~ Note that ES6 modules cannot directly export callable functions.
+ *~ This file should be imported using the CommonJS-style:
+ *~   import x = require('someLibrary');
+ *~
+ *~ Refer to the documentation to understand common
+ *~ workarounds for this limitation of ES6 modules.
+ */
+
+/*~ This declaration specifies that the function
+ *~ is the exported object from the file
+ */
+export = parser;
+
+// TODO: Conditional types in TS 1.8 will really clean this up.
+declare function parser(): parser.Processor<never>;
+declare function parser<Transform>(processor: parser.AsyncProcessor<Transform>): parser.Processor<Transform, never>;
+declare function parser(processor: parser.AsyncProcessor<void>): parser.Processor<never, never>;
+declare function parser<Transform>(processor: parser.SyncProcessor<Transform>): parser.Processor<Transform>;
+declare function parser(processor: parser.SyncProcessor<void>): parser.Processor<never>;
+declare function parser<Transform>(processor?: parser.SyncProcessor<Transform> | parser.AsyncProcessor<Transform>): parser.Processor<Transform>;
+
+/*~ If you want to expose types from your module as well, you can
+ *~ place them in this block. Often you will want to describe the
+ *~ shape of the return type of the function; that type should
+ *~ be declared in here, as this example shows.
+ */
+declare namespace parser {
+    /* copied from postcss -- so we don't need to add a dependency */
+    type ErrorOptions = {
+        plugin?: string;
+        word?: string;
+        index?: number
+    };
+    /* the bits we use of postcss.Rule, copied from postcss -- so we don't need to add a dependency */
+    type PostCSSRuleNode = {
+        selector: string
+        /**
+         * @returns postcss.CssSyntaxError but it's a complex object, caller
+         *   should cast to it if they have a dependency on postcss.
+         */
+        error(message: string, options?: ErrorOptions): Error;
+    };
+    /** Accepts a string  */
+    type Selectors = string | PostCSSRuleNode
+    type ProcessorFn<ReturnType = void> = (root: parser.Root) => ReturnType;
+    type SyncProcessor<Transform = void> = ProcessorFn<Transform>;
+    type AsyncProcessor<Transform = void> = ProcessorFn<PromiseLike<Transform>>;
+
+    const TAG: "tag";
+    const STRING: "string";
+    const SELECTOR: "selector";
+    const ROOT: "root";
+    const PSEUDO: "pseudo";
+    const NESTING: "nesting";
+    const ID: "id";
+    const COMMENT: "comment";
+    const COMBINATOR: "combinator";
+    const CLASS: "class";
+    const ATTRIBUTE: "attribute";
+    const UNIVERSAL: "universal";
+
+    interface NodeTypes {
+        tag: Tag,
+        string: String,
+        selector: Selector,
+        root: Root,
+        pseudo: Pseudo,
+        nesting: Nesting,
+        id: Identifier,
+        comment: Comment,
+        combinator: Combinator,
+        class: ClassName,
+        attribute: Attribute,
+        universal: Universal
+    }
+
+    type Node = NodeTypes[keyof NodeTypes];
+
+    function isNode(node: any): node is Node;
+
+    interface Options {
+        /**
+         * Preserve whitespace when true. Default: false;
+         */
+        lossless: boolean;
+        /**
+         * When true and a postcss.Rule is passed, set the result of
+         * processing back onto the rule when done. Default: false.
+         */
+        updateSelector: boolean;
+    }
+    class Processor<
+        TransformType = never,
+        SyncSelectorsType extends Selectors | never = Selectors
+    > {
+        res: Root;
+        readonly result: String;
+        ast(selectors: Selectors, options?: Partial<Options>): Promise<Root>;
+        astSync(selectors: SyncSelectorsType, options?: Partial<Options>): Root;
+        transform(selectors: Selectors, options?: Partial<Options>): Promise<TransformType>;
+        transformSync(selectors: SyncSelectorsType, options?: Partial<Options>): TransformType;
+        process(selectors: Selectors, options?: Partial<Options>): Promise<string>;
+        processSync(selectors: SyncSelectorsType, options?: Partial<Options>): string;
+    }
+    interface ParserOptions {
+        css: string;
+        error: (message: string, options: ErrorOptions) => Error;
+        options: Options;
+    }
+    class Parser {
+        input: ParserOptions;
+        lossy: boolean;
+        position: number;
+        root: Root;
+        selectors: string;
+        current: Selector;
+        constructor(input: ParserOptions);
+        /**
+         * Raises an error, if the processor is invoked on
+         * a postcss Rule node, a better error message is raised.
+         */
+        error(message: string, options?: ErrorOptions): void;
+    }
+    interface NodeSource {
+        start?: {
+            line: number,
+            column: number
+        },
+        end?: {
+            line: number,
+            column: number
+        }
+    }
+    interface SpaceAround {
+      before: string;
+      after: string;
+    }
+    interface Spaces extends SpaceAround {
+      [spaceType: string]: string | Partial<SpaceAround> | undefined;
+    }
+    interface NodeOptions<Value = string> {
+        value: Value;
+        spaces?: Partial<Spaces>;
+        source?: NodeSource;
+        sourceIndex?: number;
+    }
+    interface Base<
+        Value extends string | undefined = string,
+        ParentType extends Container | undefined = Container | undefined
+    > {
+        type: keyof NodeTypes;
+        parent: ParentType;
+        value: Value;
+        spaces: Spaces;
+        source?: NodeSource;
+        sourceIndex: number;
+        rawSpaceBefore: string;
+        rawSpaceAfter: string;
+        remove(): Node;
+        replaceWith(...nodes: Node[]): Node;
+        next(): Node;
+        prev(): Node;
+        clone(opts: {[override: string]:any}): Node;
+        /**
+         * Return whether this node includes the character at the position of the given line and column.
+         * Returns undefined if the nodes lack sufficient source metadata to determine the position.
+         * @param line 1-index based line number relative to the start of the selector.
+         * @param column 1-index based column number relative to the start of the selector.
+         */
+        isAtPosition(line: number, column: number): boolean | undefined;
+        /**
+         * Some non-standard syntax doesn't follow normal escaping rules for css,
+         * this allows the escaped value to be specified directly, allowing illegal characters to be
+         * directly inserted into css output.
+         * @param name the property to set
+         * @param value the unescaped value of the property
+         * @param valueEscaped optional. the escaped value of the property.
+         */
+        setPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+        /**
+         * When you want a value to passed through to CSS directly. This method
+         * deletes the corresponding raw value causing the stringifier to fallback
+         * to the unescaped value.
+         * @param name the property to set.
+         * @param value The value that is both escaped and unescaped.
+         */
+        setPropertyWithoutEscape(name: string, value: any): void;
+        /**
+         * Some non-standard syntax doesn't follow normal escaping rules for css.
+         * This allows non standard syntax to be appended to an existing property
+         * by specifying the escaped value. By specifying the escaped value,
+         * illegal characters are allowed to be directly inserted into css output.
+         * @param {string} name the property to set
+         * @param {any} value the unescaped value of the property
+         * @param {string} valueEscaped optional. the escaped value of the property.
+         */
+        appendToPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+        toString(): string;
+    }
+    interface ContainerOptions extends NodeOptions {
+        nodes?: Array<Node>;
+    }
+    interface Container<Value extends string | undefined = string> extends Base<Value> {
+        nodes: Array<Node>;
+        append(selector: Selector): Container;
+        prepend(selector: Selector): Container;
+        at(index: number): Node;
+        /**
+         * Return the most specific node at the line and column number given.
+         * The source location is based on the original parsed location, locations aren't
+         * updated as selector nodes are mutated.
+         *
+         * Note that this location is relative to the location of the first character
+         * of the selector, and not the location of the selector in the overall document
+         * when used in conjunction with postcss.
+         *
+         * If not found, returns undefined.
+         * @param line The line number of the node to find. (1-based index)
+         * @param col  The column number of the node to find. (1-based index)
+         */
+        atPosition(line: number, column: number): Node;
+        index(child: Node): number;
+        readonly first: Node;
+        readonly last: Node;
+        readonly length: number;
+        removeChild(child: Node): Container;
+        removeAll(): Container;
+        empty(): Container;
+        insertAfter(oldNode: Node, newNode: Node): Container;
+        insertBefore(oldNode: Node, newNode: Node): Container;
+        each(callback: (node: Node) => boolean | void): boolean | undefined;
+        walk(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkAttributes(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkClasses(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkCombinators(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkComments(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkIds(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkNesting(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkPseudos(callback: (node: Node) => boolean | void): boolean | undefined;
+        walkTags(callback: (node: Node) => boolean | void): boolean | undefined;
+        split(callback: (node: Node) => boolean): [Node[], Node[]];
+        map(callback: (node: Node) => Node): Node[];
+        reduce<T>(callback: (node: Node) => Node, memo: T): T;
+        every(callback: (node: Node) => boolean): boolean;
+        some(callback: (node: Node) => boolean): boolean;
+        filter(callback: (node: Node) => boolean): Node[];
+        sort(callback: (nodeA: Node, nodeB: Node) => number): Node[];
+        toString(): string;
+    }
+    function isContainer(node: any): node is Root | Selector | Pseudo;
+
+    interface NamespaceOptions<Value extends string | undefined = string> extends NodeOptions<Value> {
+        namespace?: string | true;
+    }
+    interface Namespace<Value extends string | undefined = string> extends Base<Value> {
+        /** alias for namespace */
+        ns: string | true;
+        /**
+         *  namespace prefix.
+         */
+        namespace: string | true;
+        /**
+         * If a namespace exists, prefix the value provided with it, separated by |.
+         */
+        qualifiedName(value: string): string;
+        /**
+         * A string representing the namespace suitable for output.
+         */
+        readonly namespaceString: string;
+    }
+    function isNamespace(node: any): node is Attribute | Tag;
+
+    interface Root extends Container<undefined> {
+        type: "root";
+        /**
+         * Raises an error, if the processor is invoked on
+         * a postcss Rule node, a better error message is raised.
+         */
+        error(message: string, options?: ErrorOptions): Error;
+        nodeAt(line: number, column: number): Node
+    }
+    function root(opts: ContainerOptions): Root;
+    function isRoot(node: any): node is Root;
+
+    interface Selector extends Container {
+        type: "selector";
+    }
+    function selector(opts: ContainerOptions): Selector;
+    function isSelector(node: any): node is Selector;
+
+    interface Combinator extends Base {
+        type: "combinator"
+    }
+    function combinator(opts: NodeOptions): Combinator;
+    function isCombinator(node: any): node is Combinator;
+
+    interface ClassName extends Base {
+        type: "class";
+    }
+    function className(opts: NamespaceOptions): ClassName;
+    function isClassName(node: any): node is ClassName;
+
+    type AttributeOperator = "=" | "~=" | "|=" | "^=" | "$=" | "*=";
+    type QuoteMark = '"' | "'" | null;
+    interface PreferredQuoteMarkOptions {
+        quoteMark?: QuoteMark;
+        preferCurrentQuoteMark?: boolean;
+    }
+    interface SmartQuoteMarkOptions extends PreferredQuoteMarkOptions {
+        smart?: boolean;
+    }
+    interface AttributeOptions extends NamespaceOptions<string | undefined> {
+        attribute: string;
+        operator?: AttributeOperator;
+        insensitive?: boolean;
+        quoteMark?: QuoteMark;
+        /** @deprecated Use quoteMark instead. */
+        quoted?: boolean;
+        spaces?: {
+            before?: string;
+            after?: string;
+            attribute?: Partial<SpaceAround>;
+            operator?: Partial<SpaceAround>;
+            value?: Partial<SpaceAround>;
+            insensitive?: Partial<SpaceAround>;
+        }
+        raws: {
+            unquoted?: string;
+            attribute?: string;
+            operator?: string;
+            value?: string;
+            insensitive?: string;
+            spaces?: {
+                attribute?: Partial<Spaces>;
+                operator?: Partial<Spaces>;
+                value?: Partial<Spaces>;
+                insensitive?: Partial<Spaces>;
+            }
+        };
+    }
+    interface Attribute extends Namespace<string | undefined> {
+        type: "attribute";
+        attribute: string;
+        operator?: AttributeOperator;
+        insensitive?: boolean;
+        quoteMark: QuoteMark;
+        quoted?: boolean;
+        spaces: {
+            before: string;
+            after: string;
+            attribute?: Partial<Spaces>;
+            operator?: Partial<Spaces>;
+            value?: Partial<Spaces>;
+            insensitive?: Partial<Spaces>;
+        }
+        raws: {
+            /** @deprecated The attribute value is unquoted, use that instead.. */
+            unquoted?: string;
+            attribute?: string;
+            operator?: string;
+            /** The value of the attribute with quotes and escapes. */
+            value?: string;
+            insensitive?: string;
+            spaces?: {
+                attribute?: Partial<Spaces>;
+                operator?: Partial<Spaces>;
+                value?: Partial<Spaces>;
+                insensitive?: Partial<Spaces>;
+            }
+        };
+        /**
+         * The attribute name after having been qualified with a namespace.
+         */
+        readonly qualifiedAttribute: string;
+
+        /**
+         * The case insensitivity flag or an empty string depending on whether this
+         * attribute is case insensitive.
+         */
+        readonly insensitiveFlag : 'i' | '';
+
+        /**
+         * Returns the attribute's value quoted such that it would be legal to use
+         * in the value of a css file. The original value's quotation setting
+         * used for stringification is left unchanged. See `setValue(value, options)`
+         * if you want to control the quote settings of a new value for the attribute or
+         * `set quoteMark(mark)` if you want to change the quote settings of the current
+         * value.
+         *
+         * You can also change the quotation used for the current value by setting quoteMark.
+         **/
+        getQuotedValue(options?: SmartQuoteMarkOptions): string;
+
+        /**
+         * Set the unescaped value with the specified quotation options. The value
+         * provided must not include any wrapping quote marks -- those quotes will
+         * be interpreted as part of the value and escaped accordingly.
+         * @param value
+         */
+        setValue(value: string, options?: SmartQuoteMarkOptions): void;
+
+        /**
+         * Intelligently select a quoteMark value based on the value's contents. If
+         * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+         * mark will be picked that minimizes the number of escapes.
+         *
+         * If there's no clear winner, the quote mark from these options is used,
+         * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+         * true). If the quoteMark is unspecified, a double quote is used.
+         **/
+        smartQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark;
+
+        /**
+         * Selects the preferred quote mark based on the options and the current quote mark value.
+         * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+         * instead.
+         */
+        preferredQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark
+
+        /**
+         * returns the offset of the attribute part specified relative to the
+         * start of the node of the output string.
+         *
+         * * "ns" - alias for "namespace"
+         * * "namespace" - the namespace if it exists.
+         * * "attribute" - the attribute name
+         * * "attributeNS" - the start of the attribute or its namespace
+         * * "operator" - the match operator of the attribute
+         * * "value" - The value (string or identifier)
+         * * "insensitive" - the case insensitivity flag;
+         * @param part One of the possible values inside an attribute.
+         * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+         */
+        offsetOf(part: "ns" | "namespace" | "attribute" | "attributeNS" | "operator" | "value" | "insensitive"): number;
+    }
+    function attribute(opts: AttributeOptions): Attribute;
+    function isAttribute(node: any): node is Attribute;
+
+    interface Pseudo extends Container {
+        type: "pseudo";
+    }
+    function pseudo(opts: ContainerOptions): Pseudo;
+    /**
+     * Checks wether the node is the Psuedo subtype of node.
+     */
+    function isPseudo(node: any): node is Pseudo;
+
+    /**
+     * Checks wether the node is, specifically, a pseudo element instead of
+     * pseudo class.
+     */
+    function isPseudoElement(node: any): node is Pseudo;
+
+    /**
+     * Checks wether the node is, specifically, a pseudo class instead of
+     * pseudo element.
+     */
+    function isPseudoClass(node: any): node is Pseudo;
+
+
+    interface Tag extends Namespace {
+        type: "tag";
+    }
+    function tag(opts: NamespaceOptions): Tag;
+    function isTag(node: any): node is Tag;
+
+    interface Comment extends Base {
+        type: "comment";
+    }
+    function comment(opts: NodeOptions): Comment;
+    function isComment(node: any): node is Comment;
+
+    interface Identifier extends Base {
+        type: "id";
+    }
+    function id(opts: any): any;
+    function isIdentifier(node: any): node is Identifier;
+
+    interface Nesting extends Base {
+        type: "nesting";
+    }
+    function nesting(opts: any): any;
+    function isNesting(node: any): node is Nesting;
+
+    interface String extends Base {
+        type: "string";
+    }
+    function string(opts: NodeOptions): String;
+    function isString(node: any): node is String;
+
+    interface Universal extends Base {
+        type: "universal";
+    }
+    function universal(opts?: NamespaceOptions): any;
+    function isUniversal(node: any): node is Universal;
+}