node_modules

node_modules/@vue/cli-service/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, Yuxi (Evan) You
+
+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.

node_modules/@vue/cli-service/README.md

@@ -0,0 +1,5 @@
+# @vue/cli-service
+
+> service for vue-cli
+
+[Full Docs](https://cli.vuejs.org/)

node_modules/@vue/cli-service/bin/vue-cli-service.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const semver = require('semver')
+const { error } = require('@vue/cli-shared-utils')
+const requiredVersion = require('../package.json').engines.node
+
+if (!semver.satisfies(process.version, requiredVersion)) {
+  error(
+    `You are using Node ${process.version}, but vue-cli-service ` +
+    `requires Node ${requiredVersion}.\nPlease upgrade your Node version.`
+  )
+  process.exit(1)
+}
+
+const Service = require('../lib/Service')
+const service = new Service(process.env.VUE_CLI_CONTEXT || process.cwd())
+
+const rawArgv = process.argv.slice(2)
+const args = require('minimist')(rawArgv, {
+  boolean: [
+    // build
+    'modern',
+    'report',
+    'report-json',
+    'watch',
+    // serve
+    'open',
+    'copy',
+    'https',
+    // inspect
+    'verbose'
+  ]
+})
+const command = args._[0]
+
+service.run(command, args, rawArgv).catch(err => {
+  error(err)
+  process.exit(1)
+})

node_modules/@vue/cli-service/generator/index.js

@@ -0,0 +1,72 @@
+module.exports = (api, options) => {
+  api.render('./template', {
+    doesCompile: api.hasPlugin('babel') || api.hasPlugin('typescript')
+  })
+
+  api.extendPackage({
+    scripts: {
+      'serve': 'vue-cli-service serve',
+      'build': 'vue-cli-service build'
+    },
+    dependencies: {
+      'vue': '^2.6.6'
+    },
+    devDependencies: {
+      'vue-template-compiler': '^2.5.21'
+    },
+    'postcss': {
+      'plugins': {
+        'autoprefixer': {}
+      }
+    },
+    browserslist: [
+      '> 1%',
+      'last 2 versions',
+      'not ie <= 8'
+    ]
+  })
+
+  if (options.router) {
+    require('./router')(api, options)
+  }
+
+  if (options.vuex) {
+    require('./vuex')(api, options)
+  }
+
+  if (options.cssPreprocessor) {
+    const deps = {
+      // TODO: remove 'sass' option in v4 or rename 'dart-sass' to 'sass'
+      sass: {
+        'node-sass': '^4.9.0',
+        'sass-loader': '^7.1.0'
+      },
+      'node-sass': {
+        'node-sass': '^4.9.0',
+        'sass-loader': '^7.1.0'
+      },
+      'dart-sass': {
+        fibers: '^3.1.1',
+        sass: '^1.17.2',
+        'sass-loader': '^7.1.0'
+      },
+      less: {
+        'less': '^3.0.4',
+        'less-loader': '^4.1.0'
+      },
+      stylus: {
+        'stylus': '^0.54.5',
+        'stylus-loader': '^3.0.2'
+      }
+    }
+
+    api.extendPackage({
+      devDependencies: deps[options.cssPreprocessor]
+    })
+  }
+
+  // additional tooling configurations
+  if (options.configs) {
+    api.extendPackage(options.configs)
+  }
+}

node_modules/@vue/cli-service/generator/router/index.js

@@ -0,0 +1,38 @@
+module.exports = (api, options = {}) => {
+  api.injectImports(api.entryFile, `import router from './router'`)
+  api.injectRootOptions(api.entryFile, `router`)
+  api.extendPackage({
+    dependencies: {
+      'vue-router': '^3.0.1'
+    }
+  })
+  api.render('./template', {
+    historyMode: options.routerHistoryMode,
+    doesCompile: api.hasPlugin('babel') || api.hasPlugin('typescript')
+  })
+
+  if (api.invoking) {
+    api.postProcessFiles(files => {
+      const appFile = files[`src/App.vue`]
+      if (appFile) {
+        files[`src/App.vue`] = appFile.replace(/^<template>[^]+<\/script>/, `
+<template>
+  <div id="app">
+    <div id="nav">
+      <router-link to="/">Home</router-link> |
+      <router-link to="/about">About</router-link>
+    </div>
+    <router-view/>
+  </div>
+</template>
+        `.trim())
+      }
+    })
+
+    if (api.hasPlugin('typescript')) {
+      /* eslint-disable-next-line node/no-extraneous-require */
+      const convertFiles = require('@vue/cli-plugin-typescript/generator/convert')
+      convertFiles(api)
+    }
+  }
+}

node_modules/@vue/cli-service/generator/router/template/src/router.js

@@ -0,0 +1,33 @@
+import Vue from 'vue'
+import Router from 'vue-router'
+import Home from './views/Home.vue'
+
+Vue.use(Router)
+
+export default new Router({
+  <%_ if (historyMode) { _%>
+  mode: 'history',
+  base: process.env.BASE_URL,
+  <%_ } _%>
+  routes: [
+    {
+      path: '/',
+      name: 'home',
+      component: Home
+    },
+    {
+      path: '/about',
+      name: 'about',
+      // route level code-splitting
+      // this generates a separate chunk (about.[hash].js) for this route
+      // which is lazy-loaded when the route is visited.
+      <%_ if (doesCompile) { _%>
+      component: () => import(/* webpackChunkName: "about" */ './views/About.vue')
+      <%_ } else { _%>
+      component: function () { 
+        return import(/* webpackChunkName: "about" */ './views/About.vue')
+      }
+      <%_ } _%>
+    }
+  ]
+})

node_modules/@vue/cli-service/generator/router/template/src/views/About.vue

@@ -0,0 +1,5 @@
+<template>
+  <div class="about">
+    <h1>This is an about page</h1>
+  </div>
+</template>

node_modules/@vue/cli-service/generator/router/template/src/views/Home.vue

@@ -0,0 +1,24 @@
+<template>
+  <div class="home">
+    <img alt="Vue logo" src="../assets/logo.png">
+    <%_ if (!rootOptions.bare) { _%>
+    <HelloWorld msg="Welcome to Your Vue.js App"/>
+    <%_ } else { _%>
+    <h1>Welcome to Your Vue.js App</h1>
+    <%_ } _%>
+  </div>
+</template>
+<%_ if (!rootOptions.bare) { _%>
+
+<script>
+// @ is an alias to /src
+import HelloWorld from '@/components/HelloWorld.vue'
+
+export default {
+  name: 'home',
+  components: {
+    HelloWorld
+  }
+}
+</script>
+<%_ } _%>

node_modules/@vue/cli-service/generator/template/_gitignore

@@ -0,0 +1,31 @@
+.DS_Store
+node_modules
+/dist
+<%_ if (rootOptions.plugins && rootOptions.plugins['@vue/cli-plugin-e2e-nightwatch']) { _%>
+
+/tests/e2e/reports/
+selenium-debug.log
+<%_ } _%>
+<%_ if (rootOptions.plugins && rootOptions.plugins['@vue/cli-plugin-e2e-cypress']) { _%>
+
+/tests/e2e/videos/
+/tests/e2e/screenshots/
+<%_ } _%>
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw*

node_modules/@vue/cli-service/generator/template/public/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="icon" href="<%%= BASE_URL %%>favicon.ico">
+    <title><%= rootOptions.projectName %></title>
+  </head>
+  <body>
+    <noscript>
+      <strong>We're sorry but <%= rootOptions.projectName %> doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
+    </noscript>
+    <div id="app"></div>
+    <!-- built files will be auto injected -->
+  </body>
+</html>

node_modules/@vue/cli-service/generator/template/src/App.vue

@@ -0,0 +1,109 @@
+<%_ if (!rootOptions.router) { _%>
+<template>
+  <div id="app">
+    <img alt="Vue logo" src="./assets/logo.png">
+    <%_ if (!rootOptions.bare) { _%>
+    <HelloWorld msg="Welcome to Your Vue.js App"/>
+    <%_ } else { _%>
+    <h1>Welcome to Your Vue.js App</h1>
+    <%_ } _%>
+  </div>
+</template>
+  <%_ if (!rootOptions.bare) { _%>
+
+<script>
+import HelloWorld from './components/HelloWorld.vue'
+
+export default {
+  name: 'app',
+  components: {
+    HelloWorld
+  }
+}
+</script>
+  <%_ } _%>
+<%_ } else { _%>
+<template>
+  <div id="app">
+    <div id="nav">
+      <router-link to="/">Home</router-link> |
+      <router-link to="/about">About</router-link>
+    </div>
+    <router-view/>
+  </div>
+</template>
+<%_ } _%>
+<%_ if (!rootOptions.bare) { _%>
+<%_ if (rootOptions.cssPreprocessor !== 'stylus') { _%>
+
+<style<%-
+  rootOptions.cssPreprocessor
+    ? ` lang="${
+        rootOptions.cssPreprocessor.includes('sass')
+          ? 'scss'
+          : rootOptions.cssPreprocessor
+      }"`
+    : ``
+%>>
+#app {
+  font-family: 'Avenir', Helvetica, Arial, sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-align: center;
+  color: #2c3e50;
+  <%_ if (!rootOptions.router) { _%>
+  margin-top: 60px;
+  <%_ } _%>
+}
+<%_ if (rootOptions.router) { _%>
+  <%_ if (!rootOptions.cssPreprocessor) { _%>
+#nav {
+  padding: 30px;
+}
+
+#nav a {
+  font-weight: bold;
+  color: #2c3e50;
+}
+
+#nav a.router-link-exact-active {
+  color: #42b983;
+}
+  <%_ } else { _%>
+#nav {
+  padding: 30px;
+  a {
+    font-weight: bold;
+    color: #2c3e50;
+    &.router-link-exact-active {
+      color: #42b983;
+    }
+  }
+}
+  <%_ } _%>
+<%_ } _%>
+</style>
+<%_ } else { _%>
+<style lang="stylus">
+#app
+  font-family 'Avenir', Helvetica, Arial, sans-serif
+  -webkit-font-smoothing antialiased
+  -moz-osx-font-smoothing grayscale
+  text-align center
+  color #2c3e50
+  <%_ if (!rootOptions.router) { _%>
+  margin-top 60px
+  <%_ } _%>
+<%_ if (rootOptions.router) { _%>
+
+#nav
+  padding 30px
+  a
+    font-weight bold
+    color #2c3e50
+    &.router-link-exact-active
+      color #42b983
+<%_ } _%>
+</style>
+<%_ } _%>
+<%_ } _%>

node_modules/@vue/cli-service/generator/template/src/components/HelloWorld.vue

@@ -0,0 +1,87 @@
+<%_ if (!rootOptions.bare) { _%>
+<template>
+  <div class="hello">
+    <h1>{{ msg }}</h1>
+    <p>
+      For a guide and recipes on how to configure / customize this project,<br>
+      check out the
+      <a href="https://cli.vuejs.org" target="_blank" rel="noopener">vue-cli documentation</a>.
+    </p>
+    <h3>Installed CLI Plugins</h3>
+    <ul>
+      <%_ for (plugin of plugins) { _%>
+      <li><a href="<%- plugin.link %>" target="_blank" rel="noopener"><%- plugin.name %></a></li>
+      <%_ } _%>
+    </ul>
+    <h3>Essential Links</h3>
+    <ul>
+      <li><a href="https://vuejs.org" target="_blank" rel="noopener">Core Docs</a></li>
+      <li><a href="https://forum.vuejs.org" target="_blank" rel="noopener">Forum</a></li>
+      <li><a href="https://chat.vuejs.org" target="_blank" rel="noopener">Community Chat</a></li>
+      <li><a href="https://twitter.com/vuejs" target="_blank" rel="noopener">Twitter</a></li>
+      <li><a href="https://news.vuejs.org" target="_blank" rel="noopener">News</a></li>
+    </ul>
+    <h3>Ecosystem</h3>
+    <ul>
+      <li><a href="https://router.vuejs.org" target="_blank" rel="noopener">vue-router</a></li>
+      <li><a href="https://vuex.vuejs.org" target="_blank" rel="noopener">vuex</a></li>
+      <li><a href="https://github.com/vuejs/vue-devtools#vue-devtools" target="_blank" rel="noopener">vue-devtools</a></li>
+      <li><a href="https://vue-loader.vuejs.org" target="_blank" rel="noopener">vue-loader</a></li>
+      <li><a href="https://github.com/vuejs/awesome-vue" target="_blank" rel="noopener">awesome-vue</a></li>
+    </ul>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'HelloWorld',
+  props: {
+    msg: String
+  }
+}
+</script>
+
+<!-- Add "scoped" attribute to limit CSS to this component only -->
+<%_ if (rootOptions.cssPreprocessor !== 'stylus') { _%>
+<style scoped<%-
+  rootOptions.cssPreprocessor
+    ? ` lang="${
+        rootOptions.cssPreprocessor.includes('sass')
+          ? 'scss'
+          : rootOptions.cssPreprocessor
+      }"`
+    : ``
+%>>
+h3 {
+  margin: 40px 0 0;
+}
+ul {
+  list-style-type: none;
+  padding: 0;
+}
+li {
+  display: inline-block;
+  margin: 0 10px;
+}
+a {
+  color: #42b983;
+}
+</style>
+<%_ } else { _%>
+<style scoped lang="stylus">
+h3
+  margin 40px 0 0
+
+ul
+  list-style-type none
+  padding 0
+
+li
+  display inline-block
+  margin 0 10px
+
+a
+  color #42b983
+</style>
+<%_ } _%>
+<%_ } _%>

node_modules/@vue/cli-service/generator/template/src/main.js

@@ -0,0 +1,12 @@
+import Vue from 'vue'
+import App from './App.vue'
+
+Vue.config.productionTip = false
+
+new Vue({
+  <%_ if (doesCompile) { _%>
+  render: h => h(App),
+  <%_ } else { _%>
+  render: function (h) { return h(App) },
+  <%_ } _%>
+}).$mount('#app')

node_modules/@vue/cli-service/generator/vuex/index.js

@@ -0,0 +1,16 @@
+module.exports = (api, options) => {
+  api.injectImports(api.entryFile, `import store from './store'`)
+  api.injectRootOptions(api.entryFile, `store`)
+  api.extendPackage({
+    dependencies: {
+      vuex: '^3.0.1'
+    }
+  })
+  api.render('./template')
+
+  if (api.invoking && api.hasPlugin('typescript')) {
+    /* eslint-disable-next-line node/no-extraneous-require */
+    const convertFiles = require('@vue/cli-plugin-typescript/generator/convert')
+    convertFiles(api)
+  }
+}

node_modules/@vue/cli-service/generator/vuex/template/src/store.js

@@ -0,0 +1,16 @@
+import Vue from 'vue'
+import Vuex from 'vuex'
+
+Vue.use(Vuex)
+
+export default new Vuex.Store({
+  state: {
+
+  },
+  mutations: {
+
+  },
+  actions: {
+
+  }
+})

node_modules/@vue/cli-service/lib/PluginAPI.js

@@ -0,0 +1,192 @@
+const path = require('path')
+const hash = require('hash-sum')
+const { matchesPluginId } = require('@vue/cli-shared-utils')
+
+// Note: if a plugin-registered command needs to run in a specific default mode,
+// the plugin needs to expose it via `module.exports.defaultModes` in the form
+// of { [commandName]: mode }. This is because the command mode needs to be
+// known and applied before loading user options / applying plugins.
+
+class PluginAPI {
+  /**
+   * @param {string} id - Id of the plugin.
+   * @param {Service} service - A vue-cli-service instance.
+   */
+  constructor (id, service) {
+    this.id = id
+    this.service = service
+  }
+
+  /**
+   * Current working directory.
+   */
+  getCwd () {
+    return this.service.context
+  }
+
+  /**
+   * Resolve path for a project.
+   *
+   * @param {string} _path - Relative path from project root
+   * @return {string} The resolved absolute path.
+   */
+  resolve (_path) {
+    return path.resolve(this.service.context, _path)
+  }
+
+  /**
+   * Check if the project has a given plugin.
+   *
+   * @param {string} id - Plugin id, can omit the (@vue/|vue-|@scope/vue)-cli-plugin- prefix
+   * @return {boolean}
+   */
+  hasPlugin (id) {
+    if (id === 'router') id = 'vue-router'
+    if (['vue-router', 'vuex'].includes(id)) {
+      const pkg = this.service.pkg
+      return ((pkg.dependencies && pkg.dependencies[id]) || (pkg.devDependencies && pkg.devDependencies[id]))
+    }
+    return this.service.plugins.some(p => matchesPluginId(id, p.id))
+  }
+
+  /**
+   * Register a command that will become available as `vue-cli-service [name]`.
+   *
+   * @param {string} name
+   * @param {object} [opts]
+   *   {
+   *     description: string,
+   *     usage: string,
+   *     options: { [string]: string }
+   *   }
+   * @param {function} fn
+   *   (args: { [string]: string }, rawArgs: string[]) => ?Promise
+   */
+  registerCommand (name, opts, fn) {
+    if (typeof opts === 'function') {
+      fn = opts
+      opts = null
+    }
+    this.service.commands[name] = { fn, opts: opts || {}}
+  }
+
+  /**
+   * Register a function that will receive a chainable webpack config
+   * the function is lazy and won't be called until `resolveWebpackConfig` is
+   * called
+   *
+   * @param {function} fn
+   */
+  chainWebpack (fn) {
+    this.service.webpackChainFns.push(fn)
+  }
+
+  /**
+   * Register
+   * - a webpack configuration object that will be merged into the config
+   * OR
+   * - a function that will receive the raw webpack config.
+   *   the function can either mutate the config directly or return an object
+   *   that will be merged into the config.
+   *
+   * @param {object | function} fn
+   */
+  configureWebpack (fn) {
+    this.service.webpackRawConfigFns.push(fn)
+  }
+
+  /**
+   * Register a dev serve config function. It will receive the express `app`
+   * instance of the dev server.
+   *
+   * @param {function} fn
+   */
+  configureDevServer (fn) {
+    this.service.devServerConfigFns.push(fn)
+  }
+
+  /**
+   * Resolve the final raw webpack config, that will be passed to webpack.
+   *
+   * @param {ChainableWebpackConfig} [chainableConfig]
+   * @return {object} Raw webpack config.
+   */
+  resolveWebpackConfig (chainableConfig) {
+    return this.service.resolveWebpackConfig(chainableConfig)
+  }
+
+  /**
+   * Resolve an intermediate chainable webpack config instance, which can be
+   * further tweaked before generating the final raw webpack config.
+   * You can call this multiple times to generate different branches of the
+   * base webpack config.
+   * See https://github.com/mozilla-neutrino/webpack-chain
+   *
+   * @return {ChainableWebpackConfig}
+   */
+  resolveChainableWebpackConfig () {
+    return this.service.resolveChainableWebpackConfig()
+  }
+
+  /**
+   * Generate a cache identifier from a number of variables
+   */
+  genCacheConfig (id, partialIdentifier, configFiles) {
+    const fs = require('fs')
+    const cacheDirectory = this.resolve(`node_modules/.cache/${id}`)
+
+    // replace \r\n to \n generate consistent hash
+    const fmtFunc = conf => {
+      if (typeof conf === 'function') {
+        return conf.toString().replace(/\r\n?/g, '\n')
+      }
+      return conf
+    }
+
+    const variables = {
+      partialIdentifier,
+      'cli-service': require('../package.json').version,
+      'cache-loader': require('cache-loader/package.json').version,
+      env: process.env.NODE_ENV,
+      test: !!process.env.VUE_CLI_TEST,
+      config: [
+        fmtFunc(this.service.projectOptions.chainWebpack),
+        fmtFunc(this.service.projectOptions.configureWebpack)
+      ]
+    }
+
+    if (configFiles) {
+      const readConfig = file => {
+        const absolutePath = this.resolve(file)
+        if (fs.existsSync(absolutePath)) {
+          if (absolutePath.endsWith('.js')) {
+            // should evaluate config scripts to reflect environment variable changes
+            try {
+              return JSON.stringify(require(absolutePath))
+            } catch (e) {
+              return fs.readFileSync(absolutePath, 'utf-8')
+            }
+          }
+          else {
+            return fs.readFileSync(absolutePath, 'utf-8')
+          }
+        }
+      }
+      if (!Array.isArray(configFiles)) {
+        configFiles = [configFiles]
+      }
+      for (const file of configFiles) {
+        const content = readConfig(file)
+        if (content) {
+          variables.configFiles = content.replace(/\r\n?/g, '\n')
+          break
+        }
+      }
+    }
+
+    const cacheIdentifier = hash(variables)
+    return { cacheDirectory, cacheIdentifier }
+  }
+}
+
+module.exports = PluginAPI

node_modules/@vue/cli-service/lib/Service.js

@@ -0,0 +1,422 @@
+const fs = require('fs')
+const path = require('path')
+const debug = require('debug')
+const chalk = require('chalk')
+const readPkg = require('read-pkg')
+const merge = require('webpack-merge')
+const Config = require('webpack-chain')
+const PluginAPI = require('./PluginAPI')
+const dotenv = require('dotenv')
+const dotenvExpand = require('dotenv-expand')
+const defaultsDeep = require('lodash.defaultsdeep')
+const { warn, error, isPlugin, loadModule } = require('@vue/cli-shared-utils')
+
+const { defaults, validate } = require('./options')
+
+module.exports = class Service {
+  constructor (context, { plugins, pkg, inlineOptions, useBuiltIn } = {}) {
+    process.VUE_CLI_SERVICE = this
+    this.initialized = false
+    this.context = context
+    this.inlineOptions = inlineOptions
+    this.webpackChainFns = []
+    this.webpackRawConfigFns = []
+    this.devServerConfigFns = []
+    this.commands = {}
+    // Folder containing the target package.json for plugins
+    this.pkgContext = context
+    // package.json containing the plugins
+    this.pkg = this.resolvePkg(pkg)
+    // If there are inline plugins, they will be used instead of those
+    // found in package.json.
+    // When useBuiltIn === false, built-in plugins are disabled. This is mostly
+    // for testing.
+    this.plugins = this.resolvePlugins(plugins, useBuiltIn)
+    // resolve the default mode to use for each command
+    // this is provided by plugins as module.exports.defaultModes
+    // so we can get the information without actually applying the plugin.
+    this.modes = this.plugins.reduce((modes, { apply: { defaultModes }}) => {
+      return Object.assign(modes, defaultModes)
+    }, {})
+  }
+
+  resolvePkg (inlinePkg, context = this.context) {
+    if (inlinePkg) {
+      return inlinePkg
+    } else if (fs.existsSync(path.join(context, 'package.json'))) {
+      const pkg = readPkg.sync({ cwd: context })
+      if (pkg.vuePlugins && pkg.vuePlugins.resolveFrom) {
+        this.pkgContext = path.resolve(context, pkg.vuePlugins.resolveFrom)
+        return this.resolvePkg(null, this.pkgContext)
+      }
+      return pkg
+    } else {
+      return {}
+    }
+  }
+
+  init (mode = process.env.VUE_CLI_MODE) {
+    if (this.initialized) {
+      return
+    }
+    this.initialized = true
+    this.mode = mode
+
+    // load mode .env
+    if (mode) {
+      this.loadEnv(mode)
+    }
+    // load base .env
+    this.loadEnv()
+
+    // load user config
+    const userOptions = this.loadUserOptions()
+    this.projectOptions = defaultsDeep(userOptions, defaults())
+
+    debug('vue:project-config')(this.projectOptions)
+
+    // apply plugins.
+    this.plugins.forEach(({ id, apply }) => {
+      apply(new PluginAPI(id, this), this.projectOptions)
+    })
+
+    // apply webpack configs from project config file
+    if (this.projectOptions.chainWebpack) {
+      this.webpackChainFns.push(this.projectOptions.chainWebpack)
+    }
+    if (this.projectOptions.configureWebpack) {
+      this.webpackRawConfigFns.push(this.projectOptions.configureWebpack)
+    }
+  }
+
+  loadEnv (mode) {
+    const logger = debug('vue:env')
+    const basePath = path.resolve(this.context, `.env${mode ? `.${mode}` : ``}`)
+    const localPath = `${basePath}.local`
+
+    const load = path => {
+      try {
+        const env = dotenv.config({ path, debug: process.env.DEBUG })
+        dotenvExpand(env)
+        logger(path, env)
+      } catch (err) {
+        // only ignore error if file is not found
+        if (err.toString().indexOf('ENOENT') < 0) {
+          error(err)
+        }
+      }
+    }
+
+    load(localPath)
+    load(basePath)
+
+    // by default, NODE_ENV and BABEL_ENV are set to "development" unless mode
+    // is production or test. However the value in .env files will take higher
+    // priority.
+    if (mode) {
+      // always set NODE_ENV during tests
+      // as that is necessary for tests to not be affected by each other
+      const shouldForceDefaultEnv = (
+        process.env.VUE_CLI_TEST &&
+        !process.env.VUE_CLI_TEST_TESTING_ENV
+      )
+      const defaultNodeEnv = (mode === 'production' || mode === 'test')
+        ? mode
+        : 'development'
+      if (shouldForceDefaultEnv || process.env.NODE_ENV == null) {
+        process.env.NODE_ENV = defaultNodeEnv
+      }
+      if (shouldForceDefaultEnv || process.env.BABEL_ENV == null) {
+        process.env.BABEL_ENV = defaultNodeEnv
+      }
+    }
+  }
+
+  resolvePlugins (inlinePlugins, useBuiltIn) {
+    const idToPlugin = id => ({
+      id: id.replace(/^.\//, 'built-in:'),
+      apply: require(id)
+    })
+
+    let plugins
+
+    const builtInPlugins = [
+      './commands/serve',
+      './commands/build',
+      './commands/inspect',
+      './commands/help',
+      // config plugins are order sensitive
+      './config/base',
+      './config/css',
+      './config/dev',
+      './config/prod',
+      './config/app'
+    ].map(idToPlugin)
+
+    if (inlinePlugins) {
+      plugins = useBuiltIn !== false
+        ? builtInPlugins.concat(inlinePlugins)
+        : inlinePlugins
+    } else {
+      const projectPlugins = Object.keys(this.pkg.devDependencies || {})
+        .concat(Object.keys(this.pkg.dependencies || {}))
+        .filter(isPlugin)
+        .map(id => {
+          if (
+            this.pkg.optionalDependencies &&
+            id in this.pkg.optionalDependencies
+          ) {
+            let apply = () => {}
+            try {
+              apply = require(id)
+            } catch (e) {
+              warn(`Optional dependency ${id} is not installed.`)
+            }
+
+            return { id, apply }
+          } else {
+            return idToPlugin(id)
+          }
+        })
+      plugins = builtInPlugins.concat(projectPlugins)
+    }
+
+    // Local plugins
+    if (this.pkg.vuePlugins && this.pkg.vuePlugins.service) {
+      const files = this.pkg.vuePlugins.service
+      if (!Array.isArray(files)) {
+        throw new Error(`Invalid type for option 'vuePlugins.service', expected 'array' but got ${typeof files}.`)
+      }
+      plugins = plugins.concat(files.map(file => ({
+        id: `local:${file}`,
+        apply: loadModule(file, this.pkgContext)
+      })))
+    }
+
+    return plugins
+  }
+
+  async run (name, args = {}, rawArgv = []) {
+    // resolve mode
+    // prioritize inline --mode
+    // fallback to resolved default modes from plugins or development if --watch is defined
+    const mode = args.mode || (name === 'build' && args.watch ? 'development' : this.modes[name])
+
+    // load env variables, load user config, apply plugins
+    this.init(mode)
+
+    args._ = args._ || []
+    let command = this.commands[name]
+    if (!command && name) {
+      error(`command "${name}" does not exist.`)
+      process.exit(1)
+    }
+    if (!command || args.help || args.h) {
+      command = this.commands.help
+    } else {
+      args._.shift() // remove command itself
+      rawArgv.shift()
+    }
+    const { fn } = command
+    return fn(args, rawArgv)
+  }
+
+  resolveChainableWebpackConfig () {
+    const chainableConfig = new Config()
+    // apply chains
+    this.webpackChainFns.forEach(fn => fn(chainableConfig))
+    return chainableConfig
+  }
+
+  resolveWebpackConfig (chainableConfig = this.resolveChainableWebpackConfig()) {
+    if (!this.initialized) {
+      throw new Error('Service must call init() before calling resolveWebpackConfig().')
+    }
+    // get raw config
+    let config = chainableConfig.toConfig()
+    const original = config
+    // apply raw config fns
+    this.webpackRawConfigFns.forEach(fn => {
+      if (typeof fn === 'function') {
+        // function with optional return value
+        const res = fn(config)
+        if (res) config = merge(config, res)
+      } else if (fn) {
+        // merge literal values
+        config = merge(config, fn)
+      }
+    })
+
+    // #2206 If config is merged by merge-webpack, it discards the __ruleNames
+    // information injected by webpack-chain. Restore the info so that
+    // vue inspect works properly.
+    if (config !== original) {
+      cloneRuleNames(
+        config.module && config.module.rules,
+        original.module && original.module.rules
+      )
+    }
+
+    // check if the user has manually mutated output.publicPath
+    const target = process.env.VUE_CLI_BUILD_TARGET
+    if (
+      !process.env.VUE_CLI_TEST &&
+      (target && target !== 'app') &&
+      config.output.publicPath !== this.projectOptions.publicPath
+    ) {
+      throw new Error(
+        `Do not modify webpack output.publicPath directly. ` +
+        `Use the "publicPath" option in vue.config.js instead.`
+      )
+    }
+
+    if (typeof config.entry !== 'function') {
+      let entryFiles
+      if (typeof config.entry === 'string') {
+        entryFiles = [config.entry]
+      } else if (Array.isArray(config.entry)) {
+        entryFiles = config.entry
+      } else {
+        entryFiles = Object.values(config.entry || []).reduce((allEntries, curr) => {
+          return allEntries.concat(curr)
+        }, [])
+      }
+
+      entryFiles = entryFiles.map(file => path.resolve(this.context, file))
+      process.env.VUE_CLI_ENTRY_FILES = JSON.stringify(entryFiles)
+    }
+
+    return config
+  }
+
+  loadUserOptions () {
+    // vue.config.js
+    let fileConfig, pkgConfig, resolved, resolvedFrom
+    const configPath = (
+      process.env.VUE_CLI_SERVICE_CONFIG_PATH ||
+      path.resolve(this.context, 'vue.config.js')
+    )
+    if (fs.existsSync(configPath)) {
+      try {
+        fileConfig = require(configPath)
+
+        if (typeof fileConfig === 'function') {
+          fileConfig = fileConfig()
+        }
+
+        if (!fileConfig || typeof fileConfig !== 'object') {
+          error(
+            `Error loading ${chalk.bold('vue.config.js')}: should export an object or a function that returns object.`
+          )
+          fileConfig = null
+        }
+      } catch (e) {
+        error(`Error loading ${chalk.bold('vue.config.js')}:`)
+        throw e
+      }
+    }
+
+    // package.vue
+    pkgConfig = this.pkg.vue
+    if (pkgConfig && typeof pkgConfig !== 'object') {
+      error(
+        `Error loading vue-cli config in ${chalk.bold(`package.json`)}: ` +
+        `the "vue" field should be an object.`
+      )
+      pkgConfig = null
+    }
+
+    if (fileConfig) {
+      if (pkgConfig) {
+        warn(
+          `"vue" field in package.json ignored ` +
+          `due to presence of ${chalk.bold('vue.config.js')}.`
+        )
+        warn(
+          `You should migrate it into ${chalk.bold('vue.config.js')} ` +
+          `and remove it from package.json.`
+        )
+      }
+      resolved = fileConfig
+      resolvedFrom = 'vue.config.js'
+    } else if (pkgConfig) {
+      resolved = pkgConfig
+      resolvedFrom = '"vue" field in package.json'
+    } else {
+      resolved = this.inlineOptions || {}
+      resolvedFrom = 'inline options'
+    }
+
+    if (typeof resolved.baseUrl !== 'undefined') {
+      if (typeof resolved.publicPath !== 'undefined') {
+        warn(
+          `You have set both "baseUrl" and "publicPath" in ${chalk.bold('vue.config.js')}, ` +
+          `in this case, "baseUrl" will be ignored in favor of "publicPath".`
+        )
+      } else {
+        warn(
+          `"baseUrl" option in ${chalk.bold('vue.config.js')} ` +
+          `is deprecated now, please use "publicPath" instead.`
+        )
+        resolved.publicPath = resolved.baseUrl
+      }
+    }
+
+    // normalize some options
+    ensureSlash(resolved, 'publicPath')
+    if (typeof resolved.publicPath === 'string') {
+      resolved.publicPath = resolved.publicPath.replace(/^\.\//, '')
+    }
+    // for compatibility concern, in case some plugins still rely on `baseUrl` option
+    resolved.baseUrl = resolved.publicPath
+    removeSlash(resolved, 'outputDir')
+
+    // deprecation warning
+    // TODO remove in final release
+    if (resolved.css && resolved.css.localIdentName) {
+      warn(
+        `css.localIdentName has been deprecated. ` +
+        `All css-loader options (except "modules") are now supported via css.loaderOptions.css.`
+      )
+    }
+
+    // validate options
+    validate(resolved, msg => {
+      error(
+        `Invalid options in ${chalk.bold(resolvedFrom)}: ${msg}`
+      )
+    })
+
+    return resolved
+  }
+}
+
+function ensureSlash (config, key) {
+  let val = config[key]
+  if (typeof val === 'string') {
+    if (!/^https?:/.test(val)) {
+      val = val.replace(/^([^/.])/, '/$1')
+    }
+    config[key] = val.replace(/([^/])$/, '$1/')
+  }
+}
+
+function removeSlash (config, key) {
+  if (typeof config[key] === 'string') {
+    config[key] = config[key].replace(/\/$/g, '')
+  }
+}
+
+function cloneRuleNames (to, from) {
+  if (!to || !from) {
+    return
+  }
+  from.forEach((r, i) => {
+    if (to[i]) {
+      Object.defineProperty(to[i], '__ruleNames', {
+        value: r.__ruleNames
+      })
+      cloneRuleNames(to[i].oneOf, r.oneOf)
+    }
+  })
+}

node_modules/@vue/cli-service/lib/commands/build/demo-lib-js.html

@@ -0,0 +1,10 @@
+<meta charset="utf-8">
+<title><%- htmlWebpackPlugin.options.libName %> demo</title>
+<script src="./<%- htmlWebpackPlugin.options.libName %>.umd.js"></script>
+<% if (htmlWebpackPlugin.options.cssExtract) { %>
+<link rel="stylesheet" href="./<%- htmlWebpackPlugin.options.libName %>.css">
+<% } %>
+
+<script>
+console.log(<%- htmlWebpackPlugin.options.libName %>)
+</script>

node_modules/@vue/cli-service/lib/commands/build/demo-lib.html

@@ -0,0 +1,19 @@
+<meta charset="utf-8">
+<title><%- htmlWebpackPlugin.options.libName %> demo</title>
+<script src="https://unpkg.com/vue"></script>
+<script src="./<%- htmlWebpackPlugin.options.libName %>.umd.js"></script>
+<% if (htmlWebpackPlugin.options.cssExtract) { %>
+<link rel="stylesheet" href="./<%- htmlWebpackPlugin.options.libName %>.css">
+<% } %>
+
+<div id="app">
+  <demo></demo>
+</div>
+
+<script>
+new Vue({
+  components: {
+    demo: <%- htmlWebpackPlugin.options.libName %>
+  }
+}).$mount('#app')
+</script>

node_modules/@vue/cli-service/lib/commands/build/demo-wc.html

@@ -0,0 +1,8 @@
+<meta charset="utf-8">
+<title><%- htmlWebpackPlugin.options.libName %> demo</title>
+<script src="https://unpkg.com/vue"></script>
+<script src="./<%- htmlWebpackPlugin.options.libName %>.js"></script>
+
+<% for (const comp of htmlWebpackPlugin.options.components) { %>
+<<%= comp %>></<%= comp %>>
+<% } %>

node_modules/@vue/cli-service/lib/commands/build/entry-lib-no-default.js

@@ -0,0 +1,2 @@
+import './setPublicPath'
+export * from '~entry'

node_modules/@vue/cli-service/lib/commands/build/entry-lib.js

@@ -0,0 +1,4 @@
+import './setPublicPath'
+import mod from '~entry'
+export default mod
+export * from '~entry'

node_modules/@vue/cli-service/lib/commands/build/formatStats.js

@@ -0,0 +1,68 @@
+module.exports = function formatStats (stats, dir, api) {
+  const fs = require('fs')
+  const path = require('path')
+  const zlib = require('zlib')
+  const chalk = require('chalk')
+  const ui = require('cliui')({ width: 80 })
+
+  const json = stats.toJson({
+    hash: false,
+    modules: false,
+    chunks: false
+  })
+
+  let assets = json.assets
+    ? json.assets
+    : json.children.reduce((acc, child) => acc.concat(child.assets), [])
+
+  const seenNames = new Map()
+  const isJS = val => /\.js$/.test(val)
+  const isCSS = val => /\.css$/.test(val)
+  const isMinJS = val => /\.min\.js$/.test(val)
+  assets = assets
+    .filter(a => {
+      if (seenNames.has(a.name)) {
+        return false
+      }
+      seenNames.set(a.name, true)
+      return isJS(a.name) || isCSS(a.name)
+    })
+    .sort((a, b) => {
+      if (isJS(a.name) && isCSS(b.name)) return -1
+      if (isCSS(a.name) && isJS(b.name)) return 1
+      if (isMinJS(a.name) && !isMinJS(b.name)) return -1
+      if (!isMinJS(a.name) && isMinJS(b.name)) return 1
+      return b.size - a.size
+    })
+
+  function formatSize (size) {
+    return (size / 1024).toFixed(2) + ' KiB'
+  }
+
+  function getGzippedSize (asset) {
+    const filepath = api.resolve(path.join(dir, asset.name))
+    const buffer = fs.readFileSync(filepath)
+    return formatSize(zlib.gzipSync(buffer).length)
+  }
+
+  function makeRow (a, b, c) {
+    return `  ${a}\t    ${b}\t ${c}`
+  }
+
+  ui.div(
+    makeRow(
+      chalk.cyan.bold(`File`),
+      chalk.cyan.bold(`Size`),
+      chalk.cyan.bold(`Gzipped`)
+    ) + `\n\n` +
+    assets.map(asset => makeRow(
+      /js$/.test(asset.name)
+        ? chalk.green(path.join(dir, asset.name))
+        : chalk.blue(path.join(dir, asset.name)),
+      formatSize(asset.size),
+      getGzippedSize(asset)
+    )).join(`\n`)
+  )
+
+  return `${ui.toString()}\n\n  ${chalk.gray(`Images and other types of assets omitted.`)}\n`
+}

node_modules/@vue/cli-service/lib/commands/build/index.js

@@ -0,0 +1,230 @@
+const defaults = {
+  clean: true,
+  target: 'app',
+  formats: 'commonjs,umd,umd-min',
+  'unsafe-inline': true
+}
+
+const buildModes = {
+  lib: 'library',
+  wc: 'web component',
+  'wc-async': 'web component (async)'
+}
+
+const modifyConfig = (config, fn) => {
+  if (Array.isArray(config)) {
+    config.forEach(c => fn(c))
+  } else {
+    fn(config)
+  }
+}
+
+module.exports = (api, options) => {
+  api.registerCommand('build', {
+    description: 'build for production',
+    usage: 'vue-cli-service build [options] [entry|pattern]',
+    options: {
+      '--mode': `specify env mode (default: production)`,
+      '--dest': `specify output directory (default: ${options.outputDir})`,
+      '--modern': `build app targeting modern browsers with auto fallback`,
+      '--no-unsafe-inline': `build app without introducing inline scripts`,
+      '--target': `app | lib | wc | wc-async (default: ${defaults.target})`,
+      '--formats': `list of output formats for library builds (default: ${defaults.formats})`,
+      '--name': `name for lib or web-component mode (default: "name" in package.json or entry filename)`,
+      '--no-clean': `do not remove the dist directory before building the project`,
+      '--report': `generate report.html to help analyze bundle content`,
+      '--report-json': 'generate report.json to help analyze bundle content',
+      '--watch': `watch for changes`
+    }
+  }, async (args, rawArgs) => {
+    for (const key in defaults) {
+      if (args[key] == null) {
+        args[key] = defaults[key]
+      }
+    }
+    args.entry = args.entry || args._[0]
+    if (args.target !== 'app') {
+      args.entry = args.entry || 'src/App.vue'
+    }
+
+    process.env.VUE_CLI_BUILD_TARGET = args.target
+    if (args.modern && args.target === 'app') {
+      process.env.VUE_CLI_MODERN_MODE = true
+      if (!process.env.VUE_CLI_MODERN_BUILD) {
+        // main-process for legacy build
+        await build(Object.assign({}, args, {
+          modernBuild: false,
+          keepAlive: true
+        }), api, options)
+        // spawn sub-process of self for modern build
+        const { execa } = require('@vue/cli-shared-utils')
+        const cliBin = require('path').resolve(__dirname, '../../../bin/vue-cli-service.js')
+        await execa(cliBin, ['build', ...rawArgs], {
+          stdio: 'inherit',
+          env: {
+            VUE_CLI_MODERN_BUILD: true
+          }
+        })
+      } else {
+        // sub-process for modern build
+        await build(Object.assign({}, args, {
+          modernBuild: true,
+          clean: false
+        }), api, options)
+      }
+      delete process.env.VUE_CLI_MODERN_MODE
+    } else {
+      if (args.modern) {
+        const { warn } = require('@vue/cli-shared-utils')
+        warn(
+          `Modern mode only works with default target (app). ` +
+          `For libraries or web components, use the browserslist ` +
+          `config to specify target browsers.`
+        )
+      }
+      await build(args, api, options)
+    }
+    delete process.env.VUE_CLI_BUILD_TARGET
+  })
+}
+
+async function build (args, api, options) {
+  const fs = require('fs-extra')
+  const path = require('path')
+  const chalk = require('chalk')
+  const webpack = require('webpack')
+  const formatStats = require('./formatStats')
+  const validateWebpackConfig = require('../../util/validateWebpackConfig')
+  const {
+    log,
+    done,
+    info,
+    logWithSpinner,
+    stopSpinner
+  } = require('@vue/cli-shared-utils')
+
+  log()
+  const mode = api.service.mode
+  if (args.target === 'app') {
+    const bundleTag = args.modern
+      ? args.modernBuild
+        ? `modern bundle `
+        : `legacy bundle `
+      : ``
+    logWithSpinner(`Building ${bundleTag}for ${mode}...`)
+  } else {
+    const buildMode = buildModes[args.target]
+    if (buildMode) {
+      const additionalParams = buildMode === 'library' ? ` (${args.formats})` : ``
+      logWithSpinner(`Building for ${mode} as ${buildMode}${additionalParams}...`)
+    } else {
+      throw new Error(`Unknown build target: ${args.target}`)
+    }
+  }
+
+  const targetDir = api.resolve(args.dest || options.outputDir)
+  const isLegacyBuild = args.target === 'app' && args.modern && !args.modernBuild
+
+  // resolve raw webpack config
+  let webpackConfig
+  if (args.target === 'lib') {
+    webpackConfig = require('./resolveLibConfig')(api, args, options)
+  } else if (
+    args.target === 'wc' ||
+    args.target === 'wc-async'
+  ) {
+    webpackConfig = require('./resolveWcConfig')(api, args, options)
+  } else {
+    webpackConfig = require('./resolveAppConfig')(api, args, options)
+  }
+
+  // check for common config errors
+  validateWebpackConfig(webpackConfig, api, options, args.target)
+
+  // apply inline dest path after user configureWebpack hooks
+  // so it takes higher priority
+  if (args.dest) {
+    modifyConfig(webpackConfig, config => {
+      config.output.path = targetDir
+    })
+  }
+
+  if (args.watch) {
+    modifyConfig(webpackConfig, config => {
+      config.watch = true
+    })
+  }
+
+  // Expose advanced stats
+  if (args.dashboard) {
+    const DashboardPlugin = require('../../webpack/DashboardPlugin')
+    modifyConfig(webpackConfig, config => {
+      config.plugins.push(new DashboardPlugin({
+        type: 'build',
+        modernBuild: args.modernBuild,
+        keepAlive: args.keepAlive
+      }))
+    })
+  }
+
+  if (args.report || args['report-json']) {
+    const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer')
+    modifyConfig(webpackConfig, config => {
+      const bundleName = args.target !== 'app'
+        ? config.output.filename.replace(/\.js$/, '-')
+        : isLegacyBuild ? 'legacy-' : ''
+      config.plugins.push(new BundleAnalyzerPlugin({
+        logLevel: 'warn',
+        openAnalyzer: false,
+        analyzerMode: args.report ? 'static' : 'disabled',
+        reportFilename: `${bundleName}report.html`,
+        statsFilename: `${bundleName}report.json`,
+        generateStatsFile: !!args['report-json']
+      }))
+    })
+  }
+
+  if (args.clean) {
+    await fs.remove(targetDir)
+  }
+
+  return new Promise((resolve, reject) => {
+    webpack(webpackConfig, (err, stats) => {
+      stopSpinner(false)
+      if (err) {
+        return reject(err)
+      }
+
+      if (stats.hasErrors()) {
+        return reject(`Build failed with errors.`)
+      }
+
+      if (!args.silent) {
+        const targetDirShort = path.relative(
+          api.service.context,
+          targetDir
+        )
+        log(formatStats(stats, targetDirShort, api))
+        if (args.target === 'app' && !isLegacyBuild) {
+          if (!args.watch) {
+            done(`Build complete. The ${chalk.cyan(targetDirShort)} directory is ready to be deployed.`)
+            info(`Check out deployment instructions at ${chalk.cyan(`https://cli.vuejs.org/guide/deployment.html`)}\n`)
+          } else {
+            done(`Build complete. Watching for changes...`)
+          }
+        }
+      }
+
+      // test-only signal
+      if (process.env.VUE_CLI_TEST) {
+        console.log('Build complete.')
+      }
+
+      resolve()
+    })
+  })
+}
+
+module.exports.defaultModes = {
+  build: 'production'
+}

node_modules/@vue/cli-service/lib/commands/build/resolveAppConfig.js

@@ -0,0 +1,47 @@
+module.exports = (api, args, options) => {
+  const config = api.resolveChainableWebpackConfig()
+  const targetDir = api.resolve(args.dest || options.outputDir)
+
+  // respect inline build destination in copy plugin
+  if (args.dest && config.plugins.has('copy')) {
+    config.plugin('copy').tap(args => {
+      args[0][0].to = targetDir
+      return args
+    })
+  }
+
+  if (args.modern) {
+    const ModernModePlugin = require('../../webpack/ModernModePlugin')
+    if (!args.modernBuild) {
+      // Inject plugin to extract build stats and write to disk
+      config
+        .plugin('modern-mode-legacy')
+        .use(ModernModePlugin, [{
+          targetDir,
+          isModernBuild: false,
+          unsafeInline: args['unsafe-inline']
+        }])
+    } else {
+      // Inject plugin to read non-modern build stats and inject HTML
+      config
+        .plugin('modern-mode-modern')
+        .use(ModernModePlugin, [{
+          targetDir,
+          isModernBuild: true,
+          unsafeInline: args['unsafe-inline'],
+          // as we may generate an addition file asset (if `no-unsafe-inline` specified)
+          // we need to provide the correct directory for that file to place in
+          jsDirectory: require('../../util/getAssetPath')(options, 'js')
+        }])
+    }
+  }
+
+  const rawConfig = api.resolveWebpackConfig(config)
+
+  // respect inline entry
+  if (args.entry && !options.pages) {
+    rawConfig.entry = { app: api.resolve(args.entry) }
+  }
+
+  return rawConfig
+}

node_modules/@vue/cli-service/lib/commands/build/resolveLibConfig.js

@@ -0,0 +1,134 @@
+const fs = require('fs')
+const path = require('path')
+
+module.exports = (api, { entry, name, formats }, options) => {
+  const { log, error } = require('@vue/cli-shared-utils')
+  const abort = msg => {
+    log()
+    error(msg)
+    process.exit(1)
+  }
+
+  const fullEntryPath = api.resolve(entry)
+
+  if (!fs.existsSync(fullEntryPath)) {
+    abort(
+      `Failed to resolve lib entry: ${entry}${entry === `src/App.vue` ? ' (default)' : ''}. ` +
+      `Make sure to specify the correct entry file.`
+    )
+  }
+
+  const isVueEntry = /\.vue$/.test(entry)
+  const libName = (
+    name ||
+    api.service.pkg.name ||
+    path.basename(entry).replace(/\.(jsx?|vue)$/, '')
+  )
+
+  function genConfig (format, postfix = format, genHTML) {
+    const config = api.resolveChainableWebpackConfig()
+
+    // adjust css output name so they write to the same file
+    if (config.plugins.has('extract-css')) {
+      config
+        .plugin('extract-css')
+          .tap(args => {
+            args[0].filename = `${libName}.css`
+            return args
+          })
+    }
+
+    // only minify min entry
+    if (!/\.min/.test(postfix)) {
+      config.optimization.minimize(false)
+    }
+
+    // externalize Vue in case user imports it
+    config
+      .externals({
+        ...config.get('externals'),
+        vue: {
+          commonjs: 'vue',
+          commonjs2: 'vue',
+          root: 'Vue'
+        }
+      })
+
+    // inject demo page for umd
+    if (genHTML) {
+      const template = isVueEntry ? 'demo-lib.html' : 'demo-lib-js.html'
+      config
+        .plugin('demo-html')
+          .use(require('html-webpack-plugin'), [{
+            template: path.resolve(__dirname, template),
+            inject: false,
+            filename: 'demo.html',
+            libName,
+            cssExtract: config.plugins.has('extract-css')
+          }])
+    }
+
+    // resolve entry/output
+    const entryName = `${libName}.${postfix}`
+    config.resolve
+      .alias
+        .set('~entry', fullEntryPath)
+
+    // set output target before user configureWebpack hooks are applied
+    config.output.libraryTarget(format)
+
+    // set entry/output after user configureWebpack hooks are applied
+    const rawConfig = api.resolveWebpackConfig(config)
+
+    let realEntry = require.resolve('./entry-lib.js')
+
+    // avoid importing default if user entry file does not have default export
+    if (!isVueEntry) {
+      const entryContent = fs.readFileSync(fullEntryPath, 'utf-8')
+      if (!/\b(export\s+default|export\s{[^}]+as\s+default)\b/.test(entryContent)) {
+        realEntry = require.resolve('./entry-lib-no-default.js')
+      }
+    }
+
+    rawConfig.entry = {
+      [entryName]: realEntry
+    }
+
+    rawConfig.output = Object.assign({
+      library: libName,
+      libraryExport: isVueEntry ? 'default' : undefined,
+      libraryTarget: format,
+      // preserve UDM header from webpack 3 until webpack provides either
+      // libraryTarget: 'esm' or target: 'universal'
+      // https://github.com/webpack/webpack/issues/6522
+      // https://github.com/webpack/webpack/issues/6525
+      globalObject: `(typeof self !== 'undefined' ? self : this)`
+    }, rawConfig.output, {
+      filename: `${entryName}.js`,
+      chunkFilename: `${entryName}.[name].js`,
+      // use dynamic publicPath so this can be deployed anywhere
+      // the actual path will be determined at runtime by checking
+      // document.currentScript.src.
+      publicPath: ''
+    })
+
+    return rawConfig
+  }
+
+  const configMap = {
+    commonjs: genConfig('commonjs2', 'common'),
+    umd: genConfig('umd', undefined, true),
+    'umd-min': genConfig('umd', 'umd.min')
+  }
+
+  const formatArray = (formats + '').split(',')
+  const configs = formatArray.map(format => configMap[format])
+  if (configs.indexOf(undefined) !== -1) {
+    const unknownFormats = formatArray.filter(f => configMap[f] === undefined).join(', ')
+    abort(
+      `Unknown library build formats: ${unknownFormats}`
+    )
+  }
+
+  return configs
+}

node_modules/@vue/cli-service/lib/commands/build/resolveWcConfig.js

@@ -0,0 +1,131 @@
+const path = require('path')
+const { resolveEntry, fileToComponentName } = require('./resolveWcEntry')
+
+module.exports = (api, { target, entry, name }) => {
+  // Disable CSS extraction and turn on CSS shadow mode for vue-style-loader
+  process.env.VUE_CLI_CSS_SHADOW_MODE = true
+
+  const { log, error } = require('@vue/cli-shared-utils')
+  const abort = msg => {
+    log()
+    error(msg)
+    process.exit(1)
+  }
+
+  const isAsync = /async/.test(target)
+
+  // generate dynamic entry based on glob files
+  const resolvedFiles = require('globby').sync([entry], { cwd: api.resolve('.') })
+
+  if (!resolvedFiles.length) {
+    abort(`entry pattern "${entry}" did not match any files.`)
+  }
+  let libName
+  let prefix
+  if (resolvedFiles.length === 1) {
+    // in single mode, determine the lib name from filename
+    libName = name || fileToComponentName('', resolvedFiles[0]).kebabName
+    prefix = ''
+    if (libName.indexOf('-') < 0) {
+      abort(`--name must contain a hyphen when building a single web component.`)
+    }
+  } else {
+    // multi mode
+    libName = prefix = (name || api.service.pkg.name)
+    if (!libName) {
+      abort(`--name is required when building multiple web components.`)
+    }
+  }
+
+  const dynamicEntry = resolveEntry(prefix, libName, resolvedFiles, isAsync)
+
+  function genConfig (minify, genHTML) {
+    const config = api.resolveChainableWebpackConfig()
+
+    // make sure not to transpile wc-wrapper
+    config.module
+      .rule('js')
+        .exclude
+          .add(/vue-wc-wrapper/)
+
+    // only minify min entry
+    if (!minify) {
+      config.optimization.minimize(false)
+    }
+
+    // externalize Vue in case user imports it
+    config
+      .externals({
+        ...config.get('externals'),
+        vue: 'Vue'
+      })
+
+    config
+      .plugin('web-component-options')
+        .use(require('webpack/lib/DefinePlugin'), [{
+          'process.env': {
+            CUSTOM_ELEMENT_NAME: JSON.stringify(libName)
+          }
+        }])
+
+    // enable shadow mode in vue-loader
+    config.module
+      .rule('vue')
+        .use('vue-loader')
+          .tap(options => {
+            options.shadowMode = true
+            return options
+          })
+
+    if (genHTML) {
+      config
+        .plugin('demo-html')
+          .use(require('html-webpack-plugin'), [{
+            template: path.resolve(__dirname, `./demo-wc.html`),
+            inject: false,
+            filename: 'demo.html',
+            libName,
+            components:
+              prefix === ''
+                ? [libName]
+                : resolvedFiles.map(file => {
+                  return fileToComponentName(prefix, file).kebabName
+                })
+          }])
+    }
+
+    // set entry/output last so it takes higher priority than user
+    // configureWebpack hooks
+
+    // set proxy entry for *.vue files
+    config.resolve
+      .alias
+        .set('~root', api.resolve('.'))
+
+    const rawConfig = api.resolveWebpackConfig(config)
+
+    const entryName = `${libName}${minify ? `.min` : ``}`
+    rawConfig.entry = {
+      [entryName]: dynamicEntry
+    }
+
+    Object.assign(rawConfig.output, {
+      // to ensure that multiple copies of async wc bundles can co-exist
+      // on the same page.
+      jsonpFunction: libName.replace(/-\w/g, c => c.charAt(1).toUpperCase()) + '_jsonp',
+      filename: `${entryName}.js`,
+      chunkFilename: `${libName}.[name]${minify ? `.min` : ``}.js`,
+      // use dynamic publicPath so this can be deployed anywhere
+      // the actual path will be determined at runtime by checking
+      // document.currentScript.src.
+      publicPath: ''
+    })
+
+    return rawConfig
+  }
+
+  return [
+    genConfig(false, true),
+    genConfig(true, false)
+  ]
+}

node_modules/@vue/cli-service/lib/commands/build/resolveWcEntry.js

@@ -0,0 +1,61 @@
+const fs = require('fs')
+const path = require('path')
+
+const camelizeRE = /-(\w)/g
+const camelize = str => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
+}
+
+const hyphenateRE = /\B([A-Z])/g
+const hyphenate = str => {
+  return str.replace(hyphenateRE, '-$1').toLowerCase()
+}
+
+/**
+ * Creates the script to add the component to the custom elements
+ * @param {string} prefix The prefix for the component library
+ * @param {string} component The component name for single entry builds, component file for multi-entry builds
+ * @param {string} file The file for the component
+ * @param {boolean} async Whether to load component async or not
+ */
+const createElement = (prefix, component, file, async) => {
+  const { camelName, kebabName } = exports.fileToComponentName(prefix, component)
+
+  return async
+    ? `window.customElements.define('${kebabName}', wrap(Vue, () => import('~root/${file}?shadow')))\n`
+    : `import ${camelName} from '~root/${file}?shadow'\n` +
+        `window.customElements.define('${kebabName}', wrap(Vue, ${camelName}))\n`
+}
+
+exports.fileToComponentName = (prefix, file) => {
+  const basename = path.basename(file).replace(/\.(jsx?|vue)$/, '')
+  const camelName = camelize(basename)
+  const kebabName = `${prefix ? `${prefix}-` : ``}${hyphenate(basename)}`
+  return {
+    basename,
+    camelName,
+    kebabName
+  }
+}
+
+exports.resolveEntry = (prefix, libName, files, async) => {
+  const filePath = path.resolve(__dirname, 'entry-wc.js')
+  const elements =
+    prefix === ''
+      ? [createElement('', libName, files[0])]
+      : files.map(file => createElement(prefix, file, file, async)).join('\n')
+
+  const content = `
+import './setPublicPath'
+import Vue from 'vue'
+import wrap from '@vue/web-component-wrapper'
+
+// runtime shared by every component chunk
+import 'css-loader/lib/css-base'
+import 'vue-style-loader/lib/addStylesShadow'
+import 'vue-loader/lib/runtime/componentNormalizer'
+
+${elements}`.trim()
+  fs.writeFileSync(filePath, content)
+  return filePath
+}

node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js

@@ -0,0 +1,11 @@
+// This file is imported into lib/wc client bundles.
+
+if (typeof window !== 'undefined') {
+  var i
+  if ((i = window.document.currentScript) && (i = i.src.match(/(.+\/)[^/]+\.js(\?.*)?$/))) {
+    __webpack_public_path__ = i[1] // eslint-disable-line
+  }
+}
+
+// Indicate to webpack that this file can be concatenated
+export default null

node_modules/@vue/cli-service/lib/commands/help.js

@@ -0,0 +1,63 @@
+const chalk = require('chalk')
+const padEnd = require('string.prototype.padend')
+const getPadLength = require('../util/getPadLength')
+
+module.exports = (api, options) => {
+  api.registerCommand('help', args => {
+    const command = args._[0]
+    if (!command) {
+      logMainHelp()
+    } else {
+      logHelpForCommand(command, api.service.commands[command])
+    }
+  })
+
+  function logMainHelp () {
+    console.log(
+      `\n  Usage: vue-cli-service <command> [options]\n` +
+      `\n  Commands:\n`
+    )
+    const commands = api.service.commands
+    const padLength = getPadLength(commands)
+    for (const name in commands) {
+      if (name !== 'help') {
+        const opts = commands[name].opts || {}
+        console.log(`    ${
+          chalk.blue(padEnd(name, padLength))
+        }${
+          opts.description || ''
+        }`)
+      }
+    }
+    console.log(`\n  run ${
+      chalk.green(`vue-cli-service help [command]`)
+    } for usage of a specific command.\n`)
+  }
+
+  function logHelpForCommand (name, command) {
+    if (!command) {
+      console.log(chalk.red(`\n  command "${name}" does not exist.`))
+    } else {
+      const opts = command.opts || {}
+      if (opts.usage) {
+        console.log(`\n  Usage: ${opts.usage}`)
+      }
+      if (opts.options) {
+        console.log(`\n  Options:\n`)
+        const padLength = getPadLength(opts.options)
+        for (const name in opts.options) {
+          console.log(`    ${
+            chalk.blue(padEnd(name, padLength))
+          }${
+            opts.options[name]
+          }`)
+        }
+      }
+      if (opts.details) {
+        console.log()
+        console.log(opts.details.split('\n').map(line => `  ${line}`).join('\n'))
+      }
+      console.log()
+    }
+  }
+}

node_modules/@vue/cli-service/lib/commands/inspect.js

@@ -0,0 +1,73 @@
+module.exports = (api, options) => {
+  api.registerCommand(
+    'inspect',
+    {
+      description: 'inspect internal webpack config',
+      usage: 'vue-cli-service inspect [options] [...paths]',
+      options: {
+        '--mode': 'specify env mode (default: development)',
+        '--rule <ruleName>': 'inspect a specific module rule',
+        '--plugin <pluginName>': 'inspect a specific plugin',
+        '--rules': 'list all module rule names',
+        '--plugins': 'list all plugin names',
+        '--verbose': 'show full function definitions in output'
+      }
+    },
+    args => {
+      const chalk = require('chalk')
+      const { get } = require('@vue/cli-shared-utils')
+      const { toString } = require('webpack-chain')
+      const config = api.resolveWebpackConfig()
+      const { _: paths, verbose } = args
+
+      let res
+      let hasUnnamedRule
+      if (args.rule) {
+        res = config.module.rules.find(r => r.__ruleNames[0] === args.rule)
+      } else if (args.plugin) {
+        res = config.plugins.find(p => p.__pluginName === args.plugin)
+      } else if (args.rules) {
+        res = config.module.rules.map(r => {
+          const name = r.__ruleNames ? r.__ruleNames[0] : 'Nameless Rule (*)'
+
+          hasUnnamedRule = hasUnnamedRule || !r.__ruleNames
+
+          return name
+        })
+      } else if (args.plugins) {
+        res = config.plugins.map(p => p.__pluginName || p.constructor.name)
+      } else if (paths.length > 1) {
+        res = {}
+        paths.forEach(path => {
+          res[path] = get(config, path)
+        })
+      } else if (paths.length === 1) {
+        res = get(config, paths[0])
+      } else {
+        res = config
+      }
+
+      const output = toString(res, { verbose })
+      console.log(output)
+
+      // Log explanation for Nameless Rules
+      if (hasUnnamedRule) {
+        console.log(`--- ${chalk.green('Footnotes')} ---`)
+        console.log(`*: ${chalk.green(
+          'Nameless Rules'
+        )} were added through the ${chalk.green(
+          'configureWebpack()'
+        )} API (possibly by a plugin) instead of ${chalk.green(
+          'chainWebpack()'
+        )} (recommended).
+    You can run ${chalk.green(
+    'vue-cli-service inspect'
+  )} without any arguments to inspect the full config and read these rules' config.`)
+      }
+    }
+  )
+}
+
+module.exports.defaultModes = {
+  inspect: 'development'
+}

node_modules/@vue/cli-service/lib/commands/serve.js

@@ -0,0 +1,325 @@
+const {
+  info,
+  hasProjectYarn,
+  openBrowser,
+  IpcMessenger
+} = require('@vue/cli-shared-utils')
+
+const defaults = {
+  host: '0.0.0.0',
+  port: 8080,
+  https: false
+}
+
+module.exports = (api, options) => {
+  api.registerCommand('serve', {
+    description: 'start development server',
+    usage: 'vue-cli-service serve [options] [entry]',
+    options: {
+      '--open': `open browser on server start`,
+      '--copy': `copy url to clipboard on server start`,
+      '--mode': `specify env mode (default: development)`,
+      '--host': `specify host (default: ${defaults.host})`,
+      '--port': `specify port (default: ${defaults.port})`,
+      '--https': `use https (default: ${defaults.https})`,
+      '--public': `specify the public network URL for the HMR client`
+    }
+  }, async function serve (args) {
+    info('Starting development server...')
+
+    // although this is primarily a dev server, it is possible that we
+    // are running it in a mode with a production env, e.g. in E2E tests.
+    const isInContainer = checkInContainer()
+    const isProduction = process.env.NODE_ENV === 'production'
+
+    const url = require('url')
+    const chalk = require('chalk')
+    const webpack = require('webpack')
+    const WebpackDevServer = require('webpack-dev-server')
+    const portfinder = require('portfinder')
+    const prepareURLs = require('../util/prepareURLs')
+    const prepareProxy = require('../util/prepareProxy')
+    const launchEditorMiddleware = require('launch-editor-middleware')
+    const validateWebpackConfig = require('../util/validateWebpackConfig')
+    const isAbsoluteUrl = require('../util/isAbsoluteUrl')
+
+    // resolve webpack config
+    const webpackConfig = api.resolveWebpackConfig()
+
+    // check for common config errors
+    validateWebpackConfig(webpackConfig, api, options)
+
+    // load user devServer options with higher priority than devServer
+    // in webpck config
+    const projectDevServerOptions = Object.assign(
+      webpackConfig.devServer || {},
+      options.devServer
+    )
+
+    // expose advanced stats
+    if (args.dashboard) {
+      const DashboardPlugin = require('../webpack/DashboardPlugin')
+      ;(webpackConfig.plugins = webpackConfig.plugins || []).push(new DashboardPlugin({
+        type: 'serve'
+      }))
+    }
+
+    // entry arg
+    const entry = args._[0]
+    if (entry) {
+      webpackConfig.entry = {
+        app: api.resolve(entry)
+      }
+    }
+
+    // resolve server options
+    const useHttps = args.https || projectDevServerOptions.https || defaults.https
+    const protocol = useHttps ? 'https' : 'http'
+    const host = args.host || process.env.HOST || projectDevServerOptions.host || defaults.host
+    portfinder.basePort = args.port || process.env.PORT || projectDevServerOptions.port || defaults.port
+    const port = await portfinder.getPortPromise()
+    const rawPublicUrl = args.public || projectDevServerOptions.public
+    const publicUrl = rawPublicUrl
+      ? /^[a-zA-Z]+:\/\//.test(rawPublicUrl)
+        ? rawPublicUrl
+        : `${protocol}://${rawPublicUrl}`
+      : null
+
+    const urls = prepareURLs(
+      protocol,
+      host,
+      port,
+      isAbsoluteUrl(options.publicPath) ? '/' : options.publicPath
+    )
+
+    const proxySettings = prepareProxy(
+      projectDevServerOptions.proxy,
+      api.resolve('public')
+    )
+
+    // inject dev & hot-reload middleware entries
+    if (!isProduction) {
+      const sockjsUrl = publicUrl
+        // explicitly configured via devServer.public
+        ? `?${publicUrl}/sockjs-node`
+        : isInContainer
+          // can't infer public netowrk url if inside a container...
+          // use client-side inference (note this would break with non-root publicPath)
+          ? ``
+          // otherwise infer the url
+          : `?` + url.format({
+            protocol,
+            port,
+            hostname: urls.lanUrlForConfig || 'localhost',
+            pathname: '/sockjs-node'
+          })
+      const devClients = [
+        // dev server client
+        require.resolve(`webpack-dev-server/client`) + sockjsUrl,
+        // hmr client
+        require.resolve(projectDevServerOptions.hotOnly
+          ? 'webpack/hot/only-dev-server'
+          : 'webpack/hot/dev-server')
+        // TODO custom overlay client
+        // `@vue/cli-overlay/dist/client`
+      ]
+      if (process.env.APPVEYOR) {
+        devClients.push(`webpack/hot/poll?500`)
+      }
+      // inject dev/hot client
+      addDevClientToEntry(webpackConfig, devClients)
+    }
+
+    // create compiler
+    const compiler = webpack(webpackConfig)
+
+    // create server
+    const server = new WebpackDevServer(compiler, Object.assign({
+      clientLogLevel: 'none',
+      historyApiFallback: {
+        disableDotRule: true,
+        rewrites: genHistoryApiFallbackRewrites(options.publicPath, options.pages)
+      },
+      contentBase: api.resolve('public'),
+      watchContentBase: !isProduction,
+      hot: !isProduction,
+      quiet: true,
+      compress: isProduction,
+      publicPath: options.publicPath,
+      overlay: isProduction // TODO disable this
+        ? false
+        : { warnings: false, errors: true }
+    }, projectDevServerOptions, {
+      https: useHttps,
+      proxy: proxySettings,
+      before (app, server) {
+        // launch editor support.
+        // this works with vue-devtools & @vue/cli-overlay
+        app.use('/__open-in-editor', launchEditorMiddleware(() => console.log(
+          `To specify an editor, sepcify the EDITOR env variable or ` +
+          `add "editor" field to your Vue project config.\n`
+        )))
+        // allow other plugins to register middlewares, e.g. PWA
+        api.service.devServerConfigFns.forEach(fn => fn(app, server))
+        // apply in project middlewares
+        projectDevServerOptions.before && projectDevServerOptions.before(app, server)
+      }
+    }))
+
+    ;['SIGINT', 'SIGTERM'].forEach(signal => {
+      process.on(signal, () => {
+        server.close(() => {
+          process.exit(0)
+        })
+      })
+    })
+
+    // on appveyor, killing the process with SIGTERM causes execa to
+    // throw error
+    if (process.env.VUE_CLI_TEST) {
+      process.stdin.on('data', data => {
+        if (data.toString() === 'close') {
+          console.log('got close signal!')
+          server.close(() => {
+            process.exit(0)
+          })
+        }
+      })
+    }
+
+    return new Promise((resolve, reject) => {
+      // log instructions & open browser on first compilation complete
+      let isFirstCompile = true
+      compiler.hooks.done.tap('vue-cli-service serve', stats => {
+        if (stats.hasErrors()) {
+          return
+        }
+
+        let copied = ''
+        if (isFirstCompile && args.copy) {
+          try {
+            require('clipboardy').writeSync(urls.localUrlForBrowser)
+            copied = chalk.dim('(copied to clipboard)')
+          } catch (_) {
+            /* catch exception if copy to clipboard isn't supported (e.g. WSL), see issue #3476 */
+          }
+        }
+
+        const networkUrl = publicUrl
+          ? publicUrl.replace(/([^/])$/, '$1/')
+          : urls.lanUrlForTerminal
+
+        console.log()
+        console.log(`  App running at:`)
+        console.log(`  - Local:   ${chalk.cyan(urls.localUrlForTerminal)} ${copied}`)
+        if (!isInContainer) {
+          console.log(`  - Network: ${chalk.cyan(networkUrl)}`)
+        } else {
+          console.log()
+          console.log(chalk.yellow(`  It seems you are running Vue CLI inside a container.`))
+          if (!publicUrl && options.publicPath && options.publicPath !== '/') {
+            console.log()
+            console.log(chalk.yellow(`  Since you are using a non-root publicPath, the hot-reload socket`))
+            console.log(chalk.yellow(`  will not be able to infer the correct URL to connect. You should`))
+            console.log(chalk.yellow(`  explicitly specify the URL via ${chalk.blue(`devServer.public`)}.`))
+            console.log()
+          }
+          console.log(chalk.yellow(`  Access the dev server via ${chalk.cyan(
+            `${protocol}://localhost:<your container's external mapped port>${options.publicPath}`
+          )}`))
+        }
+        console.log()
+
+        if (isFirstCompile) {
+          isFirstCompile = false
+
+          if (!isProduction) {
+            const buildCommand = hasProjectYarn(api.getCwd()) ? `yarn build` : `npm run build`
+            console.log(`  Note that the development build is not optimized.`)
+            console.log(`  To create a production build, run ${chalk.cyan(buildCommand)}.`)
+          } else {
+            console.log(`  App is served in production mode.`)
+            console.log(`  Note this is for preview or E2E testing only.`)
+          }
+          console.log()
+
+          if (args.open || projectDevServerOptions.open) {
+            const pageUri = (projectDevServerOptions.openPage && typeof projectDevServerOptions.openPage === 'string')
+              ? projectDevServerOptions.openPage
+              : ''
+            openBrowser(urls.localUrlForBrowser + pageUri)
+          }
+
+          // Send final app URL
+          if (args.dashboard) {
+            const ipc = new IpcMessenger()
+            ipc.send({
+              vueServe: {
+                url: urls.localUrlForBrowser
+              }
+            })
+          }
+
+          // resolve returned Promise
+          // so other commands can do api.service.run('serve').then(...)
+          resolve({
+            server,
+            url: urls.localUrlForBrowser
+          })
+        } else if (process.env.VUE_CLI_TEST) {
+          // signal for test to check HMR
+          console.log('App updated')
+        }
+      })
+
+      server.listen(port, host, err => {
+        if (err) {
+          reject(err)
+        }
+      })
+    })
+  })
+}
+
+function addDevClientToEntry (config, devClient) {
+  const { entry } = config
+  if (typeof entry === 'object' && !Array.isArray(entry)) {
+    Object.keys(entry).forEach((key) => {
+      entry[key] = devClient.concat(entry[key])
+    })
+  } else if (typeof entry === 'function') {
+    config.entry = entry(devClient)
+  } else {
+    config.entry = devClient.concat(entry)
+  }
+}
+
+// https://stackoverflow.com/a/20012536
+function checkInContainer () {
+  const fs = require('fs')
+  if (fs.existsSync(`/proc/1/cgroup`)) {
+    const content = fs.readFileSync(`/proc/1/cgroup`, 'utf-8')
+    return /:\/(lxc|docker|kubepods)\//.test(content)
+  }
+}
+
+function genHistoryApiFallbackRewrites (baseUrl, pages = {}) {
+  const path = require('path')
+  const multiPageRewrites = Object
+    .keys(pages)
+    // sort by length in reversed order to avoid overrides
+    // eg. 'page11' should appear in front of 'page1'
+    .sort((a, b) => b.length - a.length)
+    .map(name => ({
+      from: new RegExp(`^/${name}`),
+      to: path.posix.join(baseUrl, pages[name].filename || `${name}.html`)
+    }))
+  return [
+    ...multiPageRewrites,
+    { from: /./, to: path.posix.join(baseUrl, 'index.html') }
+  ]
+}
+
+module.exports.defaultModes = {
+  serve: 'development'
+}

node_modules/@vue/cli-service/lib/config/app.js

@@ -0,0 +1,288 @@
+// config that are specific to --target app
+const fs = require('fs')
+const path = require('path')
+
+// ensure the filename passed to html-webpack-plugin is a relative path
+// because it cannot correctly handle absolute paths
+function ensureRelative (outputDir, _path) {
+  if (path.isAbsolute(_path)) {
+    return path.relative(outputDir, _path)
+  } else {
+    return _path
+  }
+}
+
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    // only apply when there's no alternative target
+    if (process.env.VUE_CLI_BUILD_TARGET && process.env.VUE_CLI_BUILD_TARGET !== 'app') {
+      return
+    }
+
+    const isProd = process.env.NODE_ENV === 'production'
+    const isLegacyBundle = process.env.VUE_CLI_MODERN_MODE && !process.env.VUE_CLI_MODERN_BUILD
+    const outputDir = api.resolve(options.outputDir)
+
+    // code splitting
+    if (isProd && !process.env.CYPRESS_ENV) {
+      webpackConfig
+        .optimization.splitChunks({
+          cacheGroups: {
+            vendors: {
+              name: `chunk-vendors`,
+              test: /[\\/]node_modules[\\/]/,
+              priority: -10,
+              chunks: 'initial'
+            },
+            common: {
+              name: `chunk-common`,
+              minChunks: 2,
+              priority: -20,
+              chunks: 'initial',
+              reuseExistingChunk: true
+            }
+          }
+        })
+    }
+
+    // HTML plugin
+    const resolveClientEnv = require('../util/resolveClientEnv')
+
+    // #1669 html-webpack-plugin's default sort uses toposort which cannot
+    // handle cyclic deps in certain cases. Monkey patch it to handle the case
+    // before we can upgrade to its 4.0 version (incompatible with preload atm)
+    const chunkSorters = require('html-webpack-plugin/lib/chunksorter')
+    const depSort = chunkSorters.dependency
+    chunkSorters.auto = chunkSorters.dependency = (chunks, ...args) => {
+      try {
+        return depSort(chunks, ...args)
+      } catch (e) {
+        // fallback to a manual sort if that happens...
+        return chunks.sort((a, b) => {
+          // make sure user entry is loaded last so user CSS can override
+          // vendor CSS
+          if (a.id === 'app') {
+            return 1
+          } else if (b.id === 'app') {
+            return -1
+          } else if (a.entry !== b.entry) {
+            return b.entry ? -1 : 1
+          }
+          return 0
+        })
+      }
+    }
+
+    const htmlOptions = {
+      templateParameters: (compilation, assets, pluginOptions) => {
+        // enhance html-webpack-plugin's built in template params
+        let stats
+        return Object.assign({
+          // make stats lazy as it is expensive
+          get webpack () {
+            return stats || (stats = compilation.getStats().toJson())
+          },
+          compilation: compilation,
+          webpackConfig: compilation.options,
+          htmlWebpackPlugin: {
+            files: assets,
+            options: pluginOptions
+          }
+        }, resolveClientEnv(options, true /* raw */))
+      }
+    }
+
+    if (isProd) {
+      // handle indexPath
+      if (options.indexPath !== 'index.html') {
+        // why not set filename for html-webpack-plugin?
+        // 1. It cannot handle absolute paths
+        // 2. Relative paths causes incorrect SW manifest to be generated (#2007)
+        webpackConfig
+          .plugin('move-index')
+          .use(require('../webpack/MovePlugin'), [
+            path.resolve(outputDir, 'index.html'),
+            path.resolve(outputDir, options.indexPath)
+          ])
+      }
+
+      Object.assign(htmlOptions, {
+        minify: {
+          removeComments: true,
+          collapseWhitespace: true,
+          removeAttributeQuotes: true,
+          collapseBooleanAttributes: true,
+          removeScriptTypeAttributes: true
+          // more options:
+          // https://github.com/kangax/html-minifier#options-quick-reference
+        }
+      })
+
+      // keep chunk ids stable so async chunks have consistent hash (#1916)
+      webpackConfig
+        .plugin('named-chunks')
+          .use(require('webpack/lib/NamedChunksPlugin'), [chunk => {
+            if (chunk.name) {
+              return chunk.name
+            }
+
+            const hash = require('hash-sum')
+            const joinedHash = hash(
+              Array.from(chunk.modulesIterable, m => m.id).join('_')
+            )
+            return `chunk-` + joinedHash
+          }])
+    }
+
+    // resolve HTML file(s)
+    const HTMLPlugin = require('html-webpack-plugin')
+    const PreloadPlugin = require('@vue/preload-webpack-plugin')
+    const multiPageConfig = options.pages
+    const htmlPath = api.resolve('public/index.html')
+    const defaultHtmlPath = path.resolve(__dirname, 'index-default.html')
+    const publicCopyIgnore = ['.DS_Store']
+
+    if (!multiPageConfig) {
+      // default, single page setup.
+      htmlOptions.template = fs.existsSync(htmlPath)
+        ? htmlPath
+        : defaultHtmlPath
+
+      webpackConfig
+        .plugin('html')
+          .use(HTMLPlugin, [htmlOptions])
+
+      if (!isLegacyBundle) {
+        // inject preload/prefetch to HTML
+        webpackConfig
+          .plugin('preload')
+            .use(PreloadPlugin, [{
+              rel: 'preload',
+              include: 'initial',
+              fileBlacklist: [/\.map$/, /hot-update\.js$/]
+            }])
+
+        webpackConfig
+          .plugin('prefetch')
+            .use(PreloadPlugin, [{
+              rel: 'prefetch',
+              include: 'asyncChunks'
+            }])
+      }
+    } else {
+      // multi-page setup
+      webpackConfig.entryPoints.clear()
+
+      const pages = Object.keys(multiPageConfig)
+      const normalizePageConfig = c => typeof c === 'string' ? { entry: c } : c
+
+      pages.forEach(name => {
+        const pageConfig = normalizePageConfig(multiPageConfig[name])
+        const {
+          entry,
+          template = `public/${name}.html`,
+          filename = `${name}.html`,
+          chunks = ['chunk-vendors', 'chunk-common', name]
+        } = pageConfig
+
+        // Currently Cypress v3.1.0 comes with a very old version of Node,
+        // which does not support object rest syntax.
+        // (https://github.com/cypress-io/cypress/issues/2253)
+        // So here we have to extract the customHtmlOptions manually.
+        const customHtmlOptions = {}
+        for (const key in pageConfig) {
+          if (
+            !['entry', 'template', 'filename', 'chunks'].includes(key)
+          ) {
+            customHtmlOptions[key] = pageConfig[key]
+          }
+        }
+
+        // inject entry
+        webpackConfig.entry(name).add(api.resolve(entry))
+
+        // resolve page index template
+        const hasDedicatedTemplate = fs.existsSync(api.resolve(template))
+        if (hasDedicatedTemplate) {
+          publicCopyIgnore.push(template)
+        }
+        const templatePath = hasDedicatedTemplate
+          ? template
+          : fs.existsSync(htmlPath)
+            ? htmlPath
+            : defaultHtmlPath
+
+        // inject html plugin for the page
+        const pageHtmlOptions = Object.assign(
+          {},
+          htmlOptions,
+          {
+            chunks,
+            template: templatePath,
+            filename: ensureRelative(outputDir, filename)
+          },
+          customHtmlOptions
+        )
+
+        webpackConfig
+          .plugin(`html-${name}`)
+            .use(HTMLPlugin, [pageHtmlOptions])
+      })
+
+      if (!isLegacyBundle) {
+        pages.forEach(name => {
+          const filename = ensureRelative(
+            outputDir,
+            normalizePageConfig(multiPageConfig[name]).filename || `${name}.html`
+          )
+          webpackConfig
+            .plugin(`preload-${name}`)
+              .use(PreloadPlugin, [{
+                rel: 'preload',
+                includeHtmlNames: [filename],
+                include: {
+                  type: 'initial',
+                  entries: [name]
+                },
+                fileBlacklist: [/\.map$/, /hot-update\.js$/]
+              }])
+
+          webpackConfig
+            .plugin(`prefetch-${name}`)
+              .use(PreloadPlugin, [{
+                rel: 'prefetch',
+                includeHtmlNames: [filename],
+                include: {
+                  type: 'asyncChunks',
+                  entries: [name]
+                }
+              }])
+        })
+      }
+    }
+
+    // CORS and Subresource Integrity
+    if (options.crossorigin != null || options.integrity) {
+      webpackConfig
+        .plugin('cors')
+          .use(require('../webpack/CorsPlugin'), [{
+            crossorigin: options.crossorigin,
+            integrity: options.integrity,
+            publicPath: options.publicPath
+          }])
+    }
+
+    // copy static assets in public/
+    const publicDir = api.resolve('public')
+    if (!isLegacyBundle && fs.existsSync(publicDir)) {
+      webpackConfig
+        .plugin('copy')
+          .use(require('copy-webpack-plugin'), [[{
+            from: publicDir,
+            to: outputDir,
+            toType: 'dir',
+            ignore: publicCopyIgnore
+          }]])
+    }
+  })
+}

node_modules/@vue/cli-service/lib/config/base.js

@@ -0,0 +1,178 @@
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    const isLegacyBundle = process.env.VUE_CLI_MODERN_MODE && !process.env.VUE_CLI_MODERN_BUILD
+    const resolveLocal = require('../util/resolveLocal')
+    const getAssetPath = require('../util/getAssetPath')
+    const inlineLimit = 4096
+
+    const genAssetSubPath = dir => {
+      return getAssetPath(
+        options,
+        `${dir}/[name]${options.filenameHashing ? '.[hash:8]' : ''}.[ext]`
+      )
+    }
+
+    const genUrlLoaderOptions = dir => {
+      return {
+        limit: inlineLimit,
+        // use explicit fallback to avoid regression in url-loader>=1.1.0
+        fallback: {
+          loader: 'file-loader',
+          options: {
+            name: genAssetSubPath(dir)
+          }
+        }
+      }
+    }
+
+    webpackConfig
+      .mode('development')
+      .context(api.service.context)
+      .entry('app')
+        .add('./src/main.js')
+        .end()
+      .output
+        .path(api.resolve(options.outputDir))
+        .filename(isLegacyBundle ? '[name]-legacy.js' : '[name].js')
+        .publicPath(options.publicPath)
+
+    webpackConfig.resolve
+      .extensions
+        .merge(['.mjs', '.js', '.jsx', '.vue', '.json', '.wasm'])
+        .end()
+      .modules
+        .add('node_modules')
+        .add(api.resolve('node_modules'))
+        .add(resolveLocal('node_modules'))
+        .end()
+      .alias
+        .set('@', api.resolve('src'))
+        .set(
+          'vue$',
+          options.runtimeCompiler
+            ? 'vue/dist/vue.esm.js'
+            : 'vue/dist/vue.runtime.esm.js'
+        )
+
+    webpackConfig.resolveLoader
+      .modules
+        .add('node_modules')
+        .add(api.resolve('node_modules'))
+        .add(resolveLocal('node_modules'))
+
+    webpackConfig.module
+      .noParse(/^(vue|vue-router|vuex|vuex-router-sync)$/)
+
+    // js is handled by cli-plugin-babel ---------------------------------------
+
+    // vue-loader --------------------------------------------------------------
+    const vueLoaderCacheConfig = api.genCacheConfig('vue-loader', {
+      'vue-loader': require('vue-loader/package.json').version,
+      /* eslint-disable-next-line node/no-extraneous-require */
+      '@vue/component-compiler-utils': require('@vue/component-compiler-utils/package.json').version,
+      'vue-template-compiler': require('vue-template-compiler/package.json').version
+    })
+
+    webpackConfig.module
+      .rule('vue')
+        .test(/\.vue$/)
+        .use('cache-loader')
+          .loader('cache-loader')
+          .options(vueLoaderCacheConfig)
+          .end()
+        .use('vue-loader')
+          .loader('vue-loader')
+          .options(Object.assign({
+            compilerOptions: {
+              preserveWhitespace: false
+            }
+          }, vueLoaderCacheConfig))
+
+    webpackConfig
+      .plugin('vue-loader')
+      .use(require('vue-loader/lib/plugin'))
+
+    // static assets -----------------------------------------------------------
+
+    webpackConfig.module
+      .rule('images')
+        .test(/\.(png|jpe?g|gif|webp)(\?.*)?$/)
+        .use('url-loader')
+          .loader('url-loader')
+          .options(genUrlLoaderOptions('img'))
+
+    // do not base64-inline SVGs.
+    // https://github.com/facebookincubator/create-react-app/pull/1180
+    webpackConfig.module
+      .rule('svg')
+        .test(/\.(svg)(\?.*)?$/)
+        .use('file-loader')
+          .loader('file-loader')
+          .options({
+            name: genAssetSubPath('img')
+          })
+
+    webpackConfig.module
+      .rule('media')
+        .test(/\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/)
+        .use('url-loader')
+          .loader('url-loader')
+          .options(genUrlLoaderOptions('media'))
+
+    webpackConfig.module
+      .rule('fonts')
+        .test(/\.(woff2?|eot|ttf|otf)(\?.*)?$/i)
+        .use('url-loader')
+          .loader('url-loader')
+          .options(genUrlLoaderOptions('fonts'))
+
+    // Other common pre-processors ---------------------------------------------
+
+    webpackConfig.module
+      .rule('pug')
+      .test(/\.pug$/)
+      .use('pug-plain-loader')
+        .loader('pug-plain-loader')
+        .end()
+
+    // shims
+
+    webpackConfig.node
+      .merge({
+        // prevent webpack from injecting useless setImmediate polyfill because Vue
+        // source contains it (although only uses it if it's native).
+        setImmediate: false,
+        // process is injected via DefinePlugin, although some 3rd party
+        // libraries may require a mock to work properly (#934)
+        process: 'mock',
+        // prevent webpack from injecting mocks to Node native modules
+        // that does not make sense for the client
+        dgram: 'empty',
+        fs: 'empty',
+        net: 'empty',
+        tls: 'empty',
+        child_process: 'empty'
+      })
+
+    const resolveClientEnv = require('../util/resolveClientEnv')
+    webpackConfig
+      .plugin('define')
+        .use(require('webpack/lib/DefinePlugin'), [
+          resolveClientEnv(options)
+        ])
+
+    webpackConfig
+      .plugin('case-sensitive-paths')
+        .use(require('case-sensitive-paths-webpack-plugin'))
+
+    // friendly error plugin displays very confusing errors when webpack
+    // fails to resolve a loader, so we provide custom handlers to improve it
+    const { transformer, formatter } = require('../util/resolveLoaderError')
+    webpackConfig
+      .plugin('friendly-errors')
+        .use(require('@soda/friendly-errors-webpack-plugin'), [{
+          additionalTransformers: [transformer],
+          additionalFormatters: [formatter]
+        }])
+  })
+}

node_modules/@vue/cli-service/lib/config/css.js

@@ -0,0 +1,193 @@
+const fs = require('fs')
+const path = require('path')
+
+const findExisting = (context, files) => {
+  for (const file of files) {
+    if (fs.existsSync(path.join(context, file))) {
+      return file
+    }
+  }
+}
+
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    const getAssetPath = require('../util/getAssetPath')
+    const shadowMode = !!process.env.VUE_CLI_CSS_SHADOW_MODE
+    const isProd = process.env.NODE_ENV === 'production'
+
+    const defaultSassLoaderOptions = {}
+    try {
+      defaultSassLoaderOptions.implementation = require('sass')
+      defaultSassLoaderOptions.fiber = require('fibers')
+    } catch (e) {}
+
+    const {
+      modules = false,
+      extract = isProd,
+      sourceMap = false,
+      loaderOptions = {}
+    } = options.css || {}
+
+    const shouldExtract = extract !== false && !shadowMode
+    const filename = getAssetPath(
+      options,
+      `css/[name]${options.filenameHashing ? '.[contenthash:8]' : ''}.css`
+    )
+    const extractOptions = Object.assign({
+      filename,
+      chunkFilename: filename
+    }, extract && typeof extract === 'object' ? extract : {})
+
+    // use relative publicPath in extracted CSS based on extract location
+    const cssPublicPath = process.env.VUE_CLI_BUILD_TARGET === 'lib'
+      // in lib mode, CSS is extracted to dist root.
+      ? './'
+      : '../'.repeat(
+        extractOptions.filename
+            .replace(/^\.[\/\\]/, '')
+            .split(/[\/\\]/g)
+            .length - 1
+      )
+
+    // check if the project has a valid postcss config
+    // if it doesn't, don't use postcss-loader for direct style imports
+    // because otherwise it would throw error when attempting to load postcss config
+    const hasPostCSSConfig = !!(loaderOptions.postcss || api.service.pkg.postcss || findExisting(api.resolve('.'), [
+      '.postcssrc',
+      '.postcssrc.js',
+      'postcss.config.js',
+      '.postcssrc.yaml',
+      '.postcssrc.json'
+    ]))
+
+    // if building for production but not extracting CSS, we need to minimize
+    // the embbeded inline CSS as they will not be going through the optimizing
+    // plugin.
+    const needInlineMinification = isProd && !shouldExtract
+
+    const cssnanoOptions = {
+      preset: ['default', {
+        mergeLonghand: false,
+        cssDeclarationSorter: false
+      }]
+    }
+    if (options.productionSourceMap && sourceMap) {
+      cssnanoOptions.map = { inline: false }
+    }
+
+    function createCSSRule (lang, test, loader, options) {
+      const baseRule = webpackConfig.module.rule(lang).test(test)
+
+      // rules for <style lang="module">
+      const vueModulesRule = baseRule.oneOf('vue-modules').resourceQuery(/module/)
+      applyLoaders(vueModulesRule, true)
+
+      // rules for <style>
+      const vueNormalRule = baseRule.oneOf('vue').resourceQuery(/\?vue/)
+      applyLoaders(vueNormalRule, false)
+
+      // rules for *.module.* files
+      const extModulesRule = baseRule.oneOf('normal-modules').test(/\.module\.\w+$/)
+      applyLoaders(extModulesRule, true)
+
+      // rules for normal CSS imports
+      const normalRule = baseRule.oneOf('normal')
+      applyLoaders(normalRule, modules)
+
+      function applyLoaders (rule, modules) {
+        if (shouldExtract) {
+          rule
+            .use('extract-css-loader')
+            .loader(require('mini-css-extract-plugin').loader)
+            .options({
+              publicPath: cssPublicPath
+            })
+        } else {
+          rule
+            .use('vue-style-loader')
+            .loader('vue-style-loader')
+            .options({
+              sourceMap,
+              shadowMode
+            })
+        }
+
+        const cssLoaderOptions = Object.assign({
+          sourceMap,
+          importLoaders: (
+            1 + // stylePostLoader injected by vue-loader
+            (hasPostCSSConfig ? 1 : 0) +
+            (needInlineMinification ? 1 : 0)
+          )
+        }, loaderOptions.css)
+
+        if (modules) {
+          const {
+            localIdentName = '[name]_[local]_[hash:base64:5]'
+          } = loaderOptions.css || {}
+          Object.assign(cssLoaderOptions, {
+            modules,
+            localIdentName
+          })
+        }
+
+        rule
+          .use('css-loader')
+          .loader('css-loader')
+          .options(cssLoaderOptions)
+
+        if (needInlineMinification) {
+          rule
+            .use('cssnano')
+            .loader('postcss-loader')
+            .options({
+              sourceMap,
+              plugins: [require('cssnano')(cssnanoOptions)]
+            })
+        }
+
+        if (hasPostCSSConfig) {
+          rule
+            .use('postcss-loader')
+            .loader('postcss-loader')
+            .options(Object.assign({ sourceMap }, loaderOptions.postcss))
+        }
+
+        if (loader) {
+          rule
+            .use(loader)
+            .loader(loader)
+            .options(Object.assign({ sourceMap }, options))
+        }
+      }
+    }
+
+    createCSSRule('css', /\.css$/)
+    createCSSRule('postcss', /\.p(ost)?css$/)
+    createCSSRule('scss', /\.scss$/, 'sass-loader', Object.assign(defaultSassLoaderOptions, loaderOptions.sass))
+    createCSSRule('sass', /\.sass$/, 'sass-loader', Object.assign(defaultSassLoaderOptions, {
+      indentedSyntax: true
+    }, loaderOptions.sass))
+    createCSSRule('less', /\.less$/, 'less-loader', loaderOptions.less)
+    createCSSRule('stylus', /\.styl(us)?$/, 'stylus-loader', Object.assign({
+      preferPathResolver: 'webpack'
+    }, loaderOptions.stylus))
+
+    // inject CSS extraction plugin
+    if (shouldExtract) {
+      webpackConfig
+        .plugin('extract-css')
+          .use(require('mini-css-extract-plugin'), [extractOptions])
+
+      // minify extracted CSS
+      if (isProd) {
+        webpackConfig
+          .plugin('optimize-css')
+            .use(require('@intervolga/optimize-cssnano-plugin'), [{
+              sourceMap: options.productionSourceMap && sourceMap,
+              cssnanoOptions
+            }])
+      }
+    }
+  })
+}

node_modules/@vue/cli-service/lib/config/dev.js

@@ -0,0 +1,25 @@
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
+      webpackConfig
+        .devtool('cheap-module-eval-source-map')
+        .output
+          .publicPath(options.publicPath)
+
+      webpackConfig
+        .plugin('hmr')
+          .use(require('webpack/lib/HotModuleReplacementPlugin'))
+
+      // https://github.com/webpack/webpack/issues/6642
+      webpackConfig
+        .output
+          .globalObject('this')
+
+      if (!process.env.VUE_CLI_TEST && options.devServer.progress !== false) {
+        webpackConfig
+          .plugin('progress')
+          .use(require('webpack/lib/ProgressPlugin'))
+      }
+    }
+  })
+}

node_modules/@vue/cli-service/lib/config/index-default.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <title>Vue App</title>
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

node_modules/@vue/cli-service/lib/config/prod.js

@@ -0,0 +1,37 @@
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    if (process.env.NODE_ENV === 'production') {
+      const isLegacyBundle = process.env.VUE_CLI_MODERN_MODE && !process.env.VUE_CLI_MODERN_BUILD
+      const getAssetPath = require('../util/getAssetPath')
+      const filename = getAssetPath(
+        options,
+        `js/[name]${isLegacyBundle ? `-legacy` : ``}${options.filenameHashing ? '.[contenthash:8]' : ''}.js`
+      )
+
+      webpackConfig
+        .mode('production')
+        .devtool(options.productionSourceMap ? 'source-map' : false)
+        .output
+          .filename(filename)
+          .chunkFilename(filename)
+
+      // keep module.id stable when vendor modules does not change
+      webpackConfig
+        .plugin('hash-module-ids')
+          .use(require('webpack/lib/HashedModuleIdsPlugin'), [{
+            hashDigest: 'hex'
+          }])
+
+      // disable optimization during tests to speed things up
+      if (process.env.VUE_CLI_TEST) {
+        webpackConfig.optimization.minimize(false)
+      } else {
+        const TerserPlugin = require('terser-webpack-plugin')
+        const terserOptions = require('./terserOptions')
+        webpackConfig.optimization.minimizer([
+          new TerserPlugin(terserOptions(options))
+        ])
+      }
+    }
+  })
+}

node_modules/@vue/cli-service/lib/config/terserOptions.js

@@ -0,0 +1,41 @@
+module.exports = options => ({
+  terserOptions: {
+    compress: {
+      // turn off flags with small gains to speed up minification
+      arrows: false,
+      collapse_vars: false, // 0.3kb
+      comparisons: false,
+      computed_props: false,
+      hoist_funs: false,
+      hoist_props: false,
+      hoist_vars: false,
+      inline: false,
+      loops: false,
+      negate_iife: false,
+      properties: false,
+      reduce_funcs: false,
+      reduce_vars: false,
+      switches: false,
+      toplevel: false,
+      typeofs: false,
+
+      // a few flags with noticable gains/speed ratio
+      // numbers based on out of the box vendor bundle
+      booleans: true, // 0.7kb
+      if_return: true, // 0.4kb
+      sequences: true, // 0.7kb
+      unused: true, // 2.3kb
+
+      // required features to drop conditional branches
+      conditionals: true,
+      dead_code: true,
+      evaluate: true
+    },
+    mangle: {
+      safari10: true
+    }
+  },
+  sourceMap: options.productionSourceMap,
+  cache: true,
+  parallel: options.parallel
+})

node_modules/@vue/cli-service/lib/options.js

@@ -0,0 +1,134 @@
+const { createSchema, validate } = require('@vue/cli-shared-utils')
+
+const schema = createSchema(joi => joi.object({
+  baseUrl: joi.string().allow(''),
+  publicPath: joi.string().allow(''),
+  outputDir: joi.string(),
+  assetsDir: joi.string().allow(''),
+  indexPath: joi.string(),
+  filenameHashing: joi.boolean(),
+  runtimeCompiler: joi.boolean(),
+  transpileDependencies: joi.array(),
+  productionSourceMap: joi.boolean(),
+  parallel: joi.boolean(),
+  devServer: joi.object(),
+  pages: joi.object().pattern(
+    /\w+/,
+    joi.alternatives().try([
+      joi.string(),
+      joi.object().keys({
+        entry: joi.string().required()
+      }).unknown(true)
+    ])
+  ),
+  crossorigin: joi.string().valid(['', 'anonymous', 'use-credentials']),
+  integrity: joi.boolean(),
+
+  // css
+  css: joi.object({
+    modules: joi.boolean(),
+    extract: joi.alternatives().try(joi.boolean(), joi.object()),
+    sourceMap: joi.boolean(),
+    loaderOptions: joi.object({
+      css: joi.object(),
+      sass: joi.object(),
+      less: joi.object(),
+      stylus: joi.object(),
+      postcss: joi.object()
+    })
+  }),
+
+  // webpack
+  chainWebpack: joi.func(),
+  configureWebpack: joi.alternatives().try(
+    joi.object(),
+    joi.func()
+  ),
+
+  // known runtime options for built-in plugins
+  lintOnSave: joi.any().valid([true, false, 'error']),
+  pwa: joi.object(),
+
+  // 3rd party plugin options
+  pluginOptions: joi.object()
+}))
+
+exports.validate = (options, cb) => {
+  validate(options, schema, cb)
+}
+
+// #2110
+// https://github.com/nodejs/node/issues/19022
+// in some cases cpus() returns undefined, and may simply throw in the future
+function hasMultipleCores () {
+  try {
+    return require('os').cpus().length > 1
+  } catch (e) {
+    return false
+  }
+}
+
+exports.defaults = () => ({
+  // project deployment base
+  publicPath: '/',
+  // for compatibility concern. TODO: remove in v4.
+  baseUrl: '/',
+
+  // where to output built files
+  outputDir: 'dist',
+
+  // where to put static assets (js/css/img/font/...)
+  assetsDir: '',
+
+  // filename for index.html (relative to outputDir)
+  indexPath: 'index.html',
+
+  // whether filename will contain hash part
+  filenameHashing: true,
+
+  // boolean, use full build?
+  runtimeCompiler: false,
+
+  // deps to transpile
+  transpileDependencies: [/* string or regex */],
+
+  // sourceMap for production build?
+  productionSourceMap: !process.env.VUE_CLI_TEST,
+
+  // use thread-loader for babel & TS in production build
+  // enabled by default if the machine has more than 1 cores
+  parallel: hasMultipleCores(),
+
+  // multi-page config
+  pages: undefined,
+
+  // <script type="module" crossorigin="use-credentials">
+  // #1656, #1867, #2025
+  crossorigin: undefined,
+
+  // subresource integrity
+  integrity: false,
+
+  css: {
+    // extract: true,
+    // modules: false,
+    // localIdentName: '[name]_[local]_[hash:base64:5]',
+    // sourceMap: false,
+    // loaderOptions: {}
+  },
+
+  // whether to use eslint-loader
+  lintOnSave: true,
+
+  devServer: {
+  /*
+    open: process.platform === 'darwin',
+    host: '0.0.0.0',
+    port: 8080,
+    https: false,
+    hotOnly: false,
+    proxy: null, // string | Object
+    before: app => {}
+  */
+  }
+})

node_modules/@vue/cli-service/lib/util/getAssetPath.js

@@ -0,0 +1,7 @@
+const path = require('path')
+
+module.exports = function getAssetPath (options, filePath, placeAtRootIfRelative) {
+  return options.assetsDir
+    ? path.posix.join(options.assetsDir, filePath)
+    : filePath
+}

node_modules/@vue/cli-service/lib/util/getPadLength.js

@@ -0,0 +1,9 @@
+module.exports = function getPadLength (obj) {
+  let longest = 10
+  for (const name in obj) {
+    if (name.length + 1 > longest) {
+      longest = name.length + 1
+    }
+  }
+  return longest
+}

node_modules/@vue/cli-service/lib/util/isAbsoluteUrl.js

@@ -0,0 +1,4 @@
+module.exports = function isAbsoluteUrl (url) {
+  // A URL is considered absolute if it begins with "<scheme>://" or "//"
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url)
+}

node_modules/@vue/cli-service/lib/util/prepareProxy.js

@@ -0,0 +1,201 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+ */
+
+const fs = require('fs')
+const url = require('url')
+const path = require('path')
+const chalk = require('chalk')
+const address = require('address')
+
+const defaultConfig = {
+  logLevel: 'silent',
+  secure: false,
+  changeOrigin: true,
+  ws: true,
+  xfwd: true
+}
+
+module.exports = function prepareProxy (proxy, appPublicFolder) {
+  // `proxy` lets you specify alternate servers for specific requests.
+  // It can either be a string or an object conforming to the Webpack dev server proxy configuration
+  // https://webpack.github.io/docs/webpack-dev-server.html
+  if (!proxy) {
+    return undefined
+  }
+  if (Array.isArray(proxy) || (typeof proxy !== 'object' && typeof proxy !== 'string')) {
+    console.log(
+      chalk.red(
+        'When specified, "proxy" in package.json must be a string or an object.'
+      )
+    )
+    console.log(
+      chalk.red('Instead, the type of "proxy" was "' + typeof proxy + '".')
+    )
+    console.log(
+      chalk.red(
+        'Either remove "proxy" from package.json, or make it an object.'
+      )
+    )
+    process.exit(1)
+  }
+
+  // Otherwise, if proxy is specified, we will let it handle any request except for files in the public folder.
+  function mayProxy (pathname) {
+    const maybePublicPath = path.resolve(appPublicFolder, pathname.slice(1))
+    return !fs.existsSync(maybePublicPath)
+  }
+
+  function createProxyEntry (target, usersOnProxyReq, context) {
+    // #2478
+    // There're a little-known use case that the `target` field is an object rather than a string
+    // https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/https.md
+    if (typeof target === 'string' && process.platform === 'win32') {
+      target = resolveLoopback(target)
+    }
+    return {
+      target,
+      context (pathname, req) {
+        // is a static asset
+        if (!mayProxy(pathname)) {
+          return false
+        }
+        if (context) {
+          // Explicit context, e.g. /api
+          return pathname.match(context)
+        } else {
+          // not a static request
+          if (req.method !== 'GET') {
+            return true
+          }
+          // Heuristics: if request `accept`s text/html, we pick /index.html.
+          // Modern browsers include text/html into `accept` header when navigating.
+          // However API calls like `fetch()` won’t generally accept text/html.
+          // If this heuristic doesn’t work well for you, use a custom `proxy` object.
+          return (
+            req.headers.accept &&
+            req.headers.accept.indexOf('text/html') === -1
+          )
+        }
+      },
+      onProxyReq (proxyReq, req, res) {
+        if (usersOnProxyReq) {
+          usersOnProxyReq(proxyReq, req, res)
+        }
+        // Browsers may send Origin headers even with same-origin
+        // requests. To prevent CORS issues, we have to change
+        // the Origin to match the target URL.
+        if (!proxyReq.agent && proxyReq.getHeader('origin')) {
+          proxyReq.setHeader('origin', target)
+        }
+      },
+      onError: onProxyError(target)
+    }
+  }
+
+  // Support proxy as a string for those who are using the simple proxy option
+  if (typeof proxy === 'string') {
+    if (!/^http(s)?:\/\//.test(proxy)) {
+      console.log(
+        chalk.red(
+          'When "proxy" is specified in package.json it must start with either http:// or https://'
+        )
+      )
+      process.exit(1)
+    }
+
+    return [
+      Object.assign({}, defaultConfig, createProxyEntry(proxy))
+    ]
+  }
+
+  // Otherwise, proxy is an object so create an array of proxies to pass to webpackDevServer
+  return Object.keys(proxy).map(context => {
+    const config = proxy[context]
+    if (!config.hasOwnProperty('target')) {
+      console.log(
+        chalk.red(
+          'When `proxy` in package.json is an object, each `context` object must have a ' +
+            '`target` property specified as a url string'
+        )
+      )
+      process.exit(1)
+    }
+    const entry = createProxyEntry(config.target, config.onProxyReq, context)
+    return Object.assign({}, defaultConfig, config, entry)
+  })
+}
+
+function resolveLoopback (proxy) {
+  const o = url.parse(proxy)
+  o.host = undefined
+  if (o.hostname !== 'localhost') {
+    return proxy
+  }
+  // Unfortunately, many languages (unlike node) do not yet support IPv6.
+  // This means even though localhost resolves to ::1, the application
+  // must fall back to IPv4 (on 127.0.0.1).
+  // We can re-enable this in a few years.
+  /* try {
+    o.hostname = address.ipv6() ? '::1' : '127.0.0.1';
+  } catch (_ignored) {
+    o.hostname = '127.0.0.1';
+  }*/
+
+  try {
+    // Check if we're on a network; if we are, chances are we can resolve
+    // localhost. Otherwise, we can just be safe and assume localhost is
+    // IPv4 for maximum compatibility.
+    if (!address.ip()) {
+      o.hostname = '127.0.0.1'
+    }
+  } catch (_ignored) {
+    o.hostname = '127.0.0.1'
+  }
+  return url.format(o)
+}
+
+// We need to provide a custom onError function for httpProxyMiddleware.
+// It allows us to log custom error messages on the console.
+function onProxyError (proxy) {
+  return (err, req, res) => {
+    const host = req.headers && req.headers.host
+    console.log(
+      chalk.red('Proxy error:') +
+        ' Could not proxy request ' +
+        chalk.cyan(req.url) +
+        ' from ' +
+        chalk.cyan(host) +
+        ' to ' +
+        chalk.cyan(proxy) +
+        '.'
+    )
+    console.log(
+      'See https://nodejs.org/api/errors.html#errors_common_system_errors for more information (' +
+        chalk.cyan(err.code) +
+        ').'
+    )
+    console.log()
+
+    // And immediately send the proper error response to the client.
+    // Otherwise, the request will eventually timeout with ERR_EMPTY_RESPONSE on the client side.
+    if (res.writeHead && !res.headersSent) {
+      res.writeHead(500)
+    }
+    res.end(
+      'Proxy error: Could not proxy request ' +
+        req.url +
+        ' from ' +
+        host +
+        ' to ' +
+        proxy +
+        ' (' +
+        err.code +
+        ').'
+    )
+  }
+}

node_modules/@vue/cli-service/lib/util/prepareURLs.js

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+ */
+
+const url = require('url')
+const chalk = require('chalk')
+const address = require('address')
+
+module.exports = function prepareUrls (protocol, host, port, pathname = '/') {
+  const formatUrl = hostname =>
+    url.format({
+      protocol,
+      hostname,
+      port,
+      pathname
+    })
+  const prettyPrintUrl = hostname =>
+    url.format({
+      protocol,
+      hostname,
+      port: chalk.bold(port),
+      pathname
+    })
+
+  const isUnspecifiedHost = host === '0.0.0.0' || host === '::'
+  let prettyHost, lanUrlForConfig
+  let lanUrlForTerminal = chalk.gray('unavailable')
+  if (isUnspecifiedHost) {
+    prettyHost = 'localhost'
+    try {
+      // This can only return an IPv4 address
+      lanUrlForConfig = address.ip()
+      if (lanUrlForConfig) {
+        // Check if the address is a private ip
+        // https://en.wikipedia.org/wiki/Private_network#Private_IPv4_address_spaces
+        if (
+          /^10[.]|^172[.](1[6-9]|2[0-9]|3[0-1])[.]|^192[.]168[.]/.test(
+            lanUrlForConfig
+          )
+        ) {
+          // Address is private, format it for later use
+          lanUrlForTerminal = prettyPrintUrl(lanUrlForConfig)
+        } else {
+          // Address is not private, so we will discard it
+          lanUrlForConfig = undefined
+        }
+      }
+    } catch (_e) {
+      // ignored
+    }
+  } else {
+    prettyHost = host
+    lanUrlForConfig = host
+    lanUrlForTerminal = prettyPrintUrl(lanUrlForConfig)
+  }
+  const localUrlForTerminal = prettyPrintUrl(prettyHost)
+  const localUrlForBrowser = formatUrl(prettyHost)
+  return {
+    lanUrlForConfig,
+    lanUrlForTerminal,
+    localUrlForTerminal,
+    localUrlForBrowser
+  }
+}

node_modules/@vue/cli-service/lib/util/resolveClientEnv.js

@@ -0,0 +1,22 @@
+const prefixRE = /^VUE_APP_/
+
+module.exports = function resolveClientEnv (options, raw) {
+  const env = {}
+  Object.keys(process.env).forEach(key => {
+    if (prefixRE.test(key) || key === 'NODE_ENV') {
+      env[key] = process.env[key]
+    }
+  })
+  env.BASE_URL = options.publicPath
+
+  if (raw) {
+    return env
+  }
+
+  for (const key in env) {
+    env[key] = JSON.stringify(env[key])
+  }
+  return {
+    'process.env': env
+  }
+}

node_modules/@vue/cli-service/lib/util/resolveLoaderError.js

@@ -0,0 +1,47 @@
+const chalk = require('chalk')
+
+const rules = [
+  {
+    type: 'cant-resolve-loader',
+    re: /Can't resolve '(.*loader)'/,
+    msg: (e, match) => (
+      `Failed to resolve loader: ${chalk.yellow(match[1])}\n` +
+      `You may need to install it.`
+    )
+  }
+]
+
+exports.transformer = error => {
+  if (error.webpackError) {
+    const message = typeof error.webpackError === 'string'
+      ? error.webpackError
+      : error.webpackError.message || ''
+    for (const { re, msg, type } of rules) {
+      const match = message.match(re)
+      if (match) {
+        return Object.assign({}, error, {
+          // type is necessary to avoid being printed as defualt error
+          // by friendly-error-webpack-plugin
+          type,
+          shortMessage: msg(error, match)
+        })
+      }
+    }
+    // no match, unknown webpack error without a message.
+    // friendly-error-webpack-plugin fails to handle this.
+    if (!error.message) {
+      return Object.assign({}, error, {
+        type: 'unknown-webpack-error',
+        shortMessage: message
+      })
+    }
+  }
+  return error
+}
+
+exports.formatter = errors => {
+  errors = errors.filter(e => e.shortMessage)
+  if (errors.length) {
+    return errors.map(e => e.shortMessage)
+  }
+}

node_modules/@vue/cli-service/lib/util/resolveLocal.js

@@ -0,0 +1,5 @@
+const path = require('path')
+
+module.exports = function resolveLocal (...args) {
+  return path.join(__dirname, '../../', ...args)
+}

node_modules/@vue/cli-service/lib/util/validateWebpackConfig.js

@@ -0,0 +1,38 @@
+module.exports = function validateWebpackConfig (
+  webpackConfig,
+  api,
+  options,
+  target = 'app'
+) {
+  const singleConfig = Array.isArray(webpackConfig)
+    ? webpackConfig[0]
+    : webpackConfig
+
+  const actualTargetDir = singleConfig.output.path
+
+  if (actualTargetDir !== api.resolve(options.outputDir)) {
+    // user directly modifies output.path in configureWebpack or chainWebpack.
+    // this is not supported because there's no way for us to give copy
+    // plugin the correct value this way.
+    throw new Error(
+      `\n\nConfiguration Error: ` +
+      `Avoid modifying webpack output.path directly. ` +
+      `Use the "outputDir" option instead.\n`
+    )
+  }
+
+  if (actualTargetDir === api.service.context) {
+    throw new Error(
+      `\n\nConfiguration Error: ` +
+      `Do not set output directory to project root.\n`
+    )
+  }
+
+  if (target === 'app' && singleConfig.output.publicPath !== options.publicPath) {
+    throw new Error(
+      `\n\nConfiguration Error: ` +
+      `Avoid modifying webpack output.publicPath directly. ` +
+      `Use the "publicPath" option instead.\n`
+    )
+  }
+}

node_modules/@vue/cli-service/lib/webpack/CorsPlugin.js

@@ -0,0 +1,67 @@
+module.exports = class CorsPlugin {
+  constructor ({ publicPath, crossorigin, integrity }) {
+    this.crossorigin = crossorigin
+    this.integrity = integrity
+    this.publicPath = publicPath
+  }
+
+  apply (compiler) {
+    const ID = `vue-cli-cors-plugin`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      const ssri = require('ssri')
+
+      const computeHash = url => {
+        const filename = url.replace(this.publicPath, '')
+        const asset = compilation.assets[filename]
+        if (asset) {
+          const src = asset.source()
+          const integrity = ssri.fromData(src, {
+            algorithms: ['sha384']
+          })
+          return integrity.toString()
+        }
+      }
+
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tap(ID, data => {
+        const tags = [...data.head, ...data.body]
+        if (this.crossorigin != null) {
+          tags.forEach(tag => {
+            if (tag.tagName === 'script' || tag.tagName === 'link') {
+              tag.attributes.crossorigin = this.crossorigin
+            }
+          })
+        }
+        if (this.integrity) {
+          tags.forEach(tag => {
+            if (tag.tagName === 'script') {
+              const hash = computeHash(tag.attributes.src)
+              if (hash) {
+                tag.attributes.integrity = hash
+              }
+            } else if (tag.tagName === 'link' && tag.attributes.rel === 'stylesheet') {
+              const hash = computeHash(tag.attributes.href)
+              if (hash) {
+                tag.attributes.integrity = hash
+              }
+            }
+          })
+
+          // when using SRI, Chrome somehow cannot reuse
+          // the preloaded resource, and causes the files to be downloaded twice.
+          // this is a Chrome bug (https://bugs.chromium.org/p/chromium/issues/detail?id=677022)
+          // for now we disable preload if SRI is used.
+          data.head = data.head.filter(tag => {
+            return !(
+              tag.tagName === 'link' &&
+              tag.attributes.rel === 'preload'
+            )
+          })
+        }
+      })
+
+      compilation.hooks.htmlWebpackPluginAfterHtmlProcessing.tap(ID, data => {
+        data.html = data.html.replace(/\scrossorigin=""/g, ' crossorigin')
+      })
+    })
+  }
+}

node_modules/@vue/cli-service/lib/webpack/DashboardPlugin.js

@@ -0,0 +1,204 @@
+// From https://github.com/FormidableLabs/webpack-dashboard/blob/7f99b31c5f00a7818d8129cb8a8fc6eb1b71799c/plugin/index.js
+// Modified by Guillaume Chau (Akryum)
+
+/* eslint-disable max-params, max-statements */
+'use strict'
+
+const path = require('path')
+const fs = require('fs-extra')
+const webpack = require('webpack')
+const { IpcMessenger } = require('@vue/cli-shared-utils')
+const { analyzeBundle } = require('./analyzeBundle')
+
+const ID = 'vue-cli-dashboard-plugin'
+const ONE_SECOND = 1000
+const FILENAME_QUERY_REGEXP = /\?.*$/
+
+const ipc = new IpcMessenger()
+
+function getTimeMessage (timer) {
+  let time = Date.now() - timer
+
+  if (time >= ONE_SECOND) {
+    time /= ONE_SECOND
+    time = Math.round(time)
+    time += 's'
+  } else {
+    time += 'ms'
+  }
+
+  return ` (${time})`
+}
+
+class DashboardPlugin {
+  constructor (options) {
+    this.type = options.type
+    if (this.type === 'build' && options.modernBuild) {
+      this.type = 'build-modern'
+    }
+    this.watching = false
+    this.autoDisconnect = !options.keepAlive
+  }
+
+  cleanup () {
+    this.sendData = null
+    if (this.autoDisconnect) ipc.disconnect()
+  }
+
+  apply (compiler) {
+    let sendData = this.sendData
+    let timer
+
+    let assetSources = new Map()
+
+    if (!sendData) {
+      sendData = data => ipc.send({
+        webpackDashboardData: {
+          type: this.type,
+          value: data
+        }
+      })
+    }
+
+    // Progress status
+    let progressTime = Date.now()
+    const progressPlugin = new webpack.ProgressPlugin((percent, msg) => {
+      // Debouncing
+      const time = Date.now()
+      if (time - progressTime > 300) {
+        progressTime = time
+        sendData([
+          {
+            type: 'status',
+            value: 'Compiling'
+          },
+          {
+            type: 'progress',
+            value: percent
+          },
+          {
+            type: 'operations',
+            value: msg + getTimeMessage(timer)
+          }
+        ])
+      }
+    })
+    progressPlugin.apply(compiler)
+
+    compiler.hooks.watchRun.tap(ID, c => {
+      this.watching = true
+    })
+
+    compiler.hooks.run.tap(ID, c => {
+      this.watching = false
+    })
+
+    compiler.hooks.compile.tap(ID, () => {
+      timer = Date.now()
+
+      sendData([
+        {
+          type: 'status',
+          value: 'Compiling'
+        },
+        {
+          type: 'progress',
+          value: 0
+        }
+      ])
+    })
+
+    compiler.hooks.invalid.tap(ID, () => {
+      sendData([
+        {
+          type: 'status',
+          value: 'Invalidated'
+        },
+        {
+          type: 'progress',
+          value: 0
+        },
+        {
+          type: 'operations',
+          value: 'idle'
+        }
+      ])
+    })
+
+    compiler.hooks.failed.tap(ID, () => {
+      sendData([
+        {
+          type: 'status',
+          value: 'Failed'
+        },
+        {
+          type: 'operations',
+          value: `idle${getTimeMessage(timer)}`
+        }
+      ])
+    })
+
+    compiler.hooks.afterEmit.tap(ID, compilation => {
+      assetSources = new Map()
+      for (const name in compilation.assets) {
+        const asset = compilation.assets[name]
+        assetSources.set(name.replace(FILENAME_QUERY_REGEXP, ''), asset.source())
+      }
+    })
+
+    compiler.hooks.done.tap(ID, stats => {
+      let statsData = stats.toJson()
+      // Sometimes all the information is located in `children` array
+      if ((!statsData.assets || !statsData.assets.length) && statsData.children && statsData.children.length) {
+        statsData = statsData.children[0]
+      }
+
+      const outputPath = compiler.options.output.path
+      statsData.assets.forEach(asset => {
+        // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
+        asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '')
+        asset.fullPath = path.join(outputPath, asset.name)
+      })
+      // Analyze the assets and update sizes on assets and modules
+      analyzeBundle(statsData, assetSources)
+
+      const hasErrors = stats.hasErrors()
+
+      sendData([
+        {
+          type: 'status',
+          value: hasErrors ? 'Failed' : 'Success'
+        },
+        {
+          type: 'progress',
+          value: 1
+        },
+        {
+          type: 'operations',
+          value: `idle${getTimeMessage(timer)}`
+        }
+      ])
+
+      const statsFile = path.resolve(process.cwd(), `./node_modules/.stats-${this.type}.json`)
+      fs.writeJson(statsFile, {
+        errors: hasErrors,
+        warnings: stats.hasWarnings(),
+        data: statsData
+      }).then(() => {
+        sendData([
+          {
+            type: 'stats'
+          }
+        ])
+
+        if (!this.watching) {
+          this.cleanup()
+        }
+      }).catch(error => {
+        console.error(error)
+      })
+    })
+  }
+}
+
+module.exports = DashboardPlugin

node_modules/@vue/cli-service/lib/webpack/ModernModePlugin.js

@@ -0,0 +1,111 @@
+const fs = require('fs-extra')
+const path = require('path')
+
+// https://gist.github.com/samthor/64b114e4a4f539915a95b91ffd340acc
+const safariFix = `!function(){var e=document,t=e.createElement("script");if(!("noModule"in t)&&"onbeforeload"in t){var n=!1;e.addEventListener("beforeload",function(e){if(e.target===t)n=!0;else if(!e.target.hasAttribute("nomodule")||!n)return;e.preventDefault()},!0),t.type="module",t.src=".",e.head.appendChild(t),t.remove()}}();`
+
+class ModernModePlugin {
+  constructor ({ targetDir, isModernBuild, unsafeInline, jsDirectory }) {
+    this.targetDir = targetDir
+    this.isModernBuild = isModernBuild
+    this.unsafeInline = unsafeInline
+    this.jsDirectory = jsDirectory
+  }
+
+  apply (compiler) {
+    if (!this.isModernBuild) {
+      this.applyLegacy(compiler)
+    } else {
+      this.applyModern(compiler)
+    }
+  }
+
+  applyLegacy (compiler) {
+    const ID = `vue-cli-legacy-bundle`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(ID, async (data, cb) => {
+        // get stats, write to disk
+        await fs.ensureDir(this.targetDir)
+        const htmlName = path.basename(data.plugin.options.filename)
+        // Watch out for output files in sub directories
+        const htmlPath = path.dirname(data.plugin.options.filename)
+        const tempFilename = path.join(this.targetDir, htmlPath, `legacy-assets-${htmlName}.json`)
+        await fs.mkdirp(path.dirname(tempFilename))
+        await fs.writeFile(tempFilename, JSON.stringify(data.body))
+        cb()
+      })
+    })
+  }
+
+  applyModern (compiler) {
+    const ID = `vue-cli-modern-bundle`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(ID, async (data, cb) => {
+        // use <script type="module"> for modern assets
+        data.body.forEach(tag => {
+          if (tag.tagName === 'script' && tag.attributes) {
+            tag.attributes.type = 'module'
+          }
+        })
+
+        // use <link rel="modulepreload"> instead of <link rel="preload">
+        // for modern assets
+        data.head.forEach(tag => {
+          if (tag.tagName === 'link' &&
+              tag.attributes.rel === 'preload' &&
+              tag.attributes.as === 'script') {
+            tag.attributes.rel = 'modulepreload'
+          }
+        })
+
+        // inject links for legacy assets as <script nomodule>
+        const htmlName = path.basename(data.plugin.options.filename)
+        // Watch out for output files in sub directories
+        const htmlPath = path.dirname(data.plugin.options.filename)
+        const tempFilename = path.join(this.targetDir, htmlPath, `legacy-assets-${htmlName}.json`)
+        const legacyAssets = JSON.parse(await fs.readFile(tempFilename, 'utf-8'))
+          .filter(a => a.tagName === 'script' && a.attributes)
+        legacyAssets.forEach(a => { a.attributes.nomodule = '' })
+
+        if (this.unsafeInline) {
+          // inject inline Safari 10 nomodule fix
+          data.body.push({
+            tagName: 'script',
+            closeTag: true,
+            innerHTML: safariFix
+          })
+        } else {
+          // inject the fix as an external script
+          const safariFixPath = path.join(this.jsDirectory, 'safari-nomodule-fix.js')
+          const fullSafariFixPath = path.join(compilation.options.output.publicPath, safariFixPath)
+          compilation.assets[safariFixPath] = {
+            source: function () {
+              return new Buffer(safariFix)
+            },
+            size: function () {
+              return Buffer.byteLength(safariFix)
+            }
+          }
+          data.body.push({
+            tagName: 'script',
+            closeTag: true,
+            attributes: {
+              src: fullSafariFixPath
+            }
+          })
+        }
+
+        data.body.push(...legacyAssets)
+        await fs.remove(tempFilename)
+        cb()
+      })
+
+      compilation.hooks.htmlWebpackPluginAfterHtmlProcessing.tap(ID, data => {
+        data.html = data.html.replace(/\snomodule="">/g, ' nomodule>')
+      })
+    })
+  }
+}
+
+ModernModePlugin.safariFix = safariFix
+module.exports = ModernModePlugin

node_modules/@vue/cli-service/lib/webpack/MovePlugin.js

@@ -0,0 +1,16 @@
+const fs = require('fs-extra')
+
+module.exports = class MovePlugin {
+  constructor (from, to) {
+    this.from = from
+    this.to = to
+  }
+
+  apply (compiler) {
+    compiler.hooks.done.tap('move-plugin', () => {
+      if (fs.existsSync(this.from)) {
+        fs.moveSync(this.from, this.to, { overwrite: true })
+      }
+    })
+  }
+}

node_modules/@vue/cli-service/lib/webpack/analyzeBundle.js

@@ -0,0 +1,328 @@
+// From https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/ba3dbd71cec7becec0fbf529833204425f66efde/src/parseUtils.js
+// Modified by Guillaume Chau (Akryum)
+
+const acorn = require('acorn')
+const walk = require('acorn-walk')
+const mapValues = require('lodash.mapvalues')
+const transform = require('lodash.transform')
+const zlib = require('zlib')
+const { warn } = require('@vue/cli-shared-utils')
+
+exports.analyzeBundle = function analyzeBundle (bundleStats, assetSources) {
+  // Picking only `*.js` assets from bundle that has non-empty `chunks` array
+  const jsAssets = []
+  const otherAssets = []
+
+  // Separate JS assets
+  bundleStats.assets.forEach(asset => {
+    if (asset.name.endsWith('.js') && asset.chunks && asset.chunks.length) {
+      jsAssets.push(asset)
+    } else {
+      otherAssets.push(asset)
+    }
+  })
+
+  // Trying to parse bundle assets and get real module sizes
+  let bundlesSources = null
+  let parsedModules = null
+
+  bundlesSources = {}
+  parsedModules = {}
+
+  for (const asset of jsAssets) {
+    const source = assetSources.get(asset.name)
+    let bundleInfo
+
+    try {
+      bundleInfo = parseBundle(source)
+    } catch (err) {
+      bundleInfo = null
+    }
+
+    if (!bundleInfo) {
+      warn(
+        `\nCouldn't parse bundle asset "${asset.fullPath}".\n` +
+        'Analyzer will use module sizes from stats file.\n'
+      )
+      parsedModules = null
+      bundlesSources = null
+      break
+    }
+
+    bundlesSources[asset.name] = bundleInfo.src
+    Object.assign(parsedModules, bundleInfo.modules)
+  }
+
+  // Update sizes
+
+  bundleStats.modules.forEach(module => {
+    const parsedSrc = parsedModules && parsedModules[module.id]
+    module.size = {
+      stats: module.size
+    }
+    if (parsedSrc) {
+      module.size.parsed = parsedSrc.length
+      module.size.gzip = getGzipSize(parsedSrc)
+    } else {
+      module.size.parsed = module.size.stats
+      module.size.gzip = 0
+    }
+  })
+
+  jsAssets.forEach(asset => {
+    const src = bundlesSources && bundlesSources[asset.name]
+    asset.size = {
+      stats: asset.size
+    }
+    if (src) {
+      asset.size.parsed = src.length
+      asset.size.gzip = getGzipSize(src)
+    } else {
+      asset.size.parsed = asset.size.stats
+      asset.size.gzip = 0
+    }
+  }, {})
+
+  otherAssets.forEach(asset => {
+    const src = assetSources.get(asset.name)
+    asset.size = {
+      stats: asset.size,
+      parsed: asset.size
+    }
+    if (src) {
+      asset.size.gzip = getGzipSize(src)
+    } else {
+      asset.size.gzip = 0
+    }
+  })
+}
+
+function parseBundle (bundleContent) {
+  const ast = acorn.parse(bundleContent, {
+    sourceType: 'script',
+    // I believe in a bright future of ECMAScript!
+    // Actually, it's set to `2050` to support the latest ECMAScript version that currently exists.
+    // Seems like `acorn` supports such weird option value.
+    ecmaVersion: 2050
+  })
+
+  const walkState = {
+    locations: null
+  }
+
+  walk.recursive(
+    ast,
+    walkState,
+    {
+      CallExpression (node, state, c) {
+        if (state.sizes) return
+
+        const args = node.arguments
+
+        // Additional bundle without webpack loader.
+        // Modules are stored in second argument, after chunk ids:
+        // webpackJsonp([<chunks>], <modules>, ...)
+        // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+        if (
+          node.callee.type === 'Identifier' &&
+          args.length >= 2 &&
+          isArgumentContainsChunkIds(args[0]) &&
+          isArgumentContainsModulesList(args[1])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[1])
+          return
+        }
+
+        // Additional bundle without webpack loader, with module IDs optimized.
+        // Modules are stored in second arguments Array(n).concat() call
+        // webpackJsonp([<chunks>], Array([minimum ID]).concat([<module>, <module>, ...]))
+        // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+        if (
+          node.callee.type === 'Identifier' &&
+          (args.length === 2 || args.length === 3) &&
+          isArgumentContainsChunkIds(args[0]) &&
+          isArgumentArrayConcatContainingChunks(args[1])
+        ) {
+          state.locations = getModulesLocationFromArrayConcat(args[1])
+          return
+        }
+
+        // Main bundle with webpack loader
+        // Modules are stored in first argument:
+        // (function (...) {...})(<modules>)
+        if (
+          node.callee.type === 'FunctionExpression' &&
+          !node.callee.id &&
+          args.length === 1 &&
+          isArgumentContainsModulesList(args[0])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[0])
+          return
+        }
+
+        // Additional bundles with webpack 4 are loaded with:
+        // (window.webpackJsonp=window.webpackJsonp||[]).push([[chunkId], [<module>, <module>], [[optional_entries]]]);
+        if (
+          isWindowPropertyPushExpression(node) &&
+          args.length === 1 &&
+          isArgumentContainingChunkIdsAndModulesList(args[0])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[0].elements[1])
+          return
+        }
+
+        // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
+        // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
+        args.forEach(arg => c(arg, state))
+      }
+    }
+  )
+
+  if (!walkState.locations) {
+    return null
+  }
+
+  return {
+    src: bundleContent,
+    modules: mapValues(walkState.locations,
+      loc => bundleContent.slice(loc.start, loc.end)
+    )
+  }
+}
+
+function getGzipSize (buffer) {
+  return zlib.gzipSync(buffer).length
+}
+
+function isArgumentContainsChunkIds (arg) {
+  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
+  return (arg.type === 'ArrayExpression' && arg.elements.every(isModuleId))
+}
+
+function isArgumentContainsModulesList (arg) {
+  if (arg.type === 'ObjectExpression') {
+    return arg.properties
+      .map(arg => arg.value)
+      .every(isModuleWrapper)
+  }
+
+  if (arg.type === 'ArrayExpression') {
+    // Modules are contained in array.
+    // Array indexes are module ids
+    return arg.elements.every(elem =>
+      // Some of array items may be skipped because there is no module with such id
+      !elem ||
+      isModuleWrapper(elem)
+    )
+  }
+
+  return false
+}
+
+function isArgumentContainingChunkIdsAndModulesList (arg) {
+  if (
+    arg.type === 'ArrayExpression' &&
+    arg.elements.length >= 2 &&
+    isArgumentContainsChunkIds(arg.elements[0]) &&
+    isArgumentContainsModulesList(arg.elements[1])
+  ) {
+    return true
+  }
+  return false
+}
+
+function isArgumentArrayConcatContainingChunks (arg) {
+  if (
+    arg.type === 'CallExpression' &&
+    arg.callee.type === 'MemberExpression' &&
+    // Make sure the object called is `Array(<some number>)`
+    arg.callee.object.type === 'CallExpression' &&
+    arg.callee.object.callee.type === 'Identifier' &&
+    arg.callee.object.callee.name === 'Array' &&
+    arg.callee.object.arguments.length === 1 &&
+    isNumericId(arg.callee.object.arguments[0]) &&
+    // Make sure the property X called for `Array(<some number>).X` is `concat`
+    arg.callee.property.type === 'Identifier' &&
+    arg.callee.property.name === 'concat' &&
+    // Make sure exactly one array is passed in to `concat`
+    arg.arguments.length === 1 &&
+    arg.arguments[0].type === 'ArrayExpression'
+  ) {
+    // Modules are contained in `Array(<minimum ID>).concat(` array:
+    // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
+    // The `<minimum ID>` + array indexes are module ids
+    return true
+  }
+
+  return false
+}
+
+function isWindowPropertyPushExpression (node) {
+  return node.callee.type === 'MemberExpression' &&
+    node.callee.property.name === 'push' &&
+    node.callee.object.type === 'AssignmentExpression' &&
+    node.callee.object.left.object.name === 'window'
+}
+
+function isModuleWrapper (node) {
+  return (
+    // It's an anonymous function expression that wraps module
+    ((node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.id) ||
+    // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) ||
+    // or an array of shape [<module_id>, ...args]
+    (node.type === 'ArrayExpression' && node.elements.length > 1 && isModuleId(node.elements[0]))
+  )
+}
+
+function isModuleId (node) {
+  return (node.type === 'Literal' && (isNumericId(node) || typeof node.value === 'string'))
+}
+
+function isNumericId (node) {
+  return (node.type === 'Literal' && Number.isInteger(node.value) && node.value >= 0)
+}
+
+function getModulesLocationFromFunctionArgument (arg) {
+  if (arg.type === 'ObjectExpression') {
+    const modulesNodes = arg.properties
+
+    return transform(modulesNodes, (result, moduleNode) => {
+      const moduleId = moduleNode.key.name || moduleNode.key.value
+
+      result[moduleId] = getModuleLocation(moduleNode.value)
+    }, {})
+  }
+
+  if (arg.type === 'ArrayExpression') {
+    const modulesNodes = arg.elements
+
+    return transform(modulesNodes, (result, moduleNode, i) => {
+      if (!moduleNode) return
+
+      result[i] = getModuleLocation(moduleNode)
+    }, {})
+  }
+
+  return {}
+}
+
+function getModulesLocationFromArrayConcat (arg) {
+  // arg(CallExpression) =
+  //   Array([minId]).concat([<minId module>, <minId+1 module>, ...])
+  //
+  // Get the [minId] value from the Array() call first argument literal value
+  const minId = arg.callee.object.arguments[0].value
+  // The modules reside in the `concat()` function call arguments
+  const modulesNodes = arg.arguments[0].elements
+
+  return transform(modulesNodes, (result, moduleNode, i) => {
+    if (!moduleNode) return
+
+    result[i + minId] = getModuleLocation(moduleNode)
+  }, {})
+}
+
+function getModuleLocation (node) {
+  return { start: node.start, end: node.end }
+}

node_modules/@vue/cli-service/node_modules/.bin/acorn

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../acorn/bin/acorn" "$@"
+  ret=$?
+else 
+  node  "$basedir/../acorn/bin/acorn" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/@vue/cli-service/node_modules/.bin/acorn.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\acorn\bin\acorn" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\acorn\bin\acorn" %*
+)

node_modules/@vue/cli-service/node_modules/acorn/CHANGELOG.md

@@ -0,0 +1,514 @@
+## 6.1.1 (2019-02-27)
+
+### Bug fixes
+
+Fix bug that caused parsing default exports of with names to fail.
+
+## 6.1.0 (2019-02-08)
+
+### Bug fixes
+
+Fix scope checking when redefining a `var` as a lexical binding.
+
+### New features
+
+Split up `parseSubscripts` to use an internal `parseSubscript` method to make it easier to extend with plugins.
+
+## 6.0.7 (2019-02-04)
+
+### Bug fixes
+
+Check that exported bindings are defined.
+
+Don't treat `\u180e` as a whitespace character.
+
+Check for duplicate parameter names in methods.
+
+Don't allow shorthand properties when they are generators or async methods.
+
+Forbid binding `await` in async arrow function's parameter list.
+
+## 6.0.6 (2019-01-30)
+
+### Bug fixes
+
+The content of class declarations and expressions is now always parsed in strict mode.
+
+Don't allow `let` or `const` to bind the variable name `let`.
+
+Treat class declarations as lexical.
+
+Don't allow a generator function declaration as the sole body of an `if` or `else`.
+
+Ignore `"use strict"` when after an empty statement.
+
+Allow string line continuations with special line terminator characters.
+
+Treat `for` bodies as part of the `for` scope when checking for conflicting bindings.
+
+Fix bug with parsing `yield` in a `for` loop initializer.
+
+Implement special cases around scope checking for functions.
+
+## 6.0.5 (2019-01-02)
+
+### Bug fixes
+
+Fix TypeScript type for `Parser.extend` and add `allowAwaitOutsideFunction` to options type.
+
+Don't treat `let` as a keyword when the next token is `{` on the next line.
+
+Fix bug that broke checking for parentheses around an object pattern in a destructuring assignment when `preserveParens` was on.
+
+## 6.0.4 (2018-11-05)
+
+### Bug fixes
+
+Further improvements to tokenizing regular expressions in corner cases.
+
+## 6.0.3 (2018-11-04)
+
+### Bug fixes
+
+Fix bug in tokenizing an expression-less return followed by a function followed by a regular expression.
+
+Remove stray symlink in the package tarball.
+
+## 6.0.2 (2018-09-26)
+
+### Bug fixes
+
+Fix bug where default expressions could fail to parse inside an object destructuring assignment expression.
+
+## 6.0.1 (2018-09-14)
+
+### Bug fixes
+
+Fix wrong value in `version` export.
+
+## 6.0.0 (2018-09-14)
+
+### Bug fixes
+
+Better handle variable-redefinition checks for catch bindings and functions directly under if statements.
+
+Forbid `new.target` in top-level arrow functions.
+
+Fix issue with parsing a regexp after `yield` in some contexts.
+
+### New features
+
+The package now comes with TypeScript definitions.
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 9 (2018).
+
+Plugins work differently, and will have to be rewritten to work with this version.
+
+The loose parser and walker have been moved into separate packages (`acorn-loose` and `acorn-walk`).
+
+## 5.7.3 (2018-09-10)
+
+### Bug fixes
+
+Fix failure to tokenize regexps after expressions like `x.of`.
+
+Better error message for unterminated template literals.
+
+## 5.7.2 (2018-08-24)
+
+### Bug fixes
+
+Properly handle `allowAwaitOutsideFunction` in for statements.
+
+Treat function declarations at the top level of modules like let bindings.
+
+Don't allow async function declarations as the only statement under a label.
+
+## 5.7.0 (2018-06-15)
+
+### New features
+
+Upgraded to Unicode 11.
+
+## 5.6.0 (2018-05-31)
+
+### New features
+
+Allow U+2028 and U+2029 in string when ECMAVersion >= 10.
+
+Allow binding-less catch statements when ECMAVersion >= 10.
+
+Add `allowAwaitOutsideFunction` option for parsing top-level `await`.
+
+## 5.5.3 (2018-03-08)
+
+### Bug fixes
+
+A _second_ republish of the code in 5.5.1, this time with yarn, to hopefully get valid timestamps.
+
+## 5.5.2 (2018-03-08)
+
+### Bug fixes
+
+A republish of the code in 5.5.1 in an attempt to solve an issue with the file timestamps in the npm package being 0.
+
+## 5.5.1 (2018-03-06)
+
+### Bug fixes
+
+Fix misleading error message for octal escapes in template strings.
+
+## 5.5.0 (2018-02-27)
+
+### New features
+
+The identifier character categorization is now based on Unicode version 10.
+
+Acorn will now validate the content of regular expressions, including new ES9 features.
+
+## 5.4.0 (2018-02-01)
+
+### Bug fixes
+
+Disallow duplicate or escaped flags on regular expressions.
+
+Disallow octal escapes in strings in strict mode.
+
+### New features
+
+Add support for async iteration.
+
+Add support for object spread and rest.
+
+## 5.3.0 (2017-12-28)
+
+### Bug fixes
+
+Fix parsing of floating point literals with leading zeroes in loose mode.
+
+Allow duplicate property names in object patterns.
+
+Don't allow static class methods named `prototype`.
+
+Disallow async functions directly under `if` or `else`.
+
+Parse right-hand-side of `for`/`of` as an assignment expression.
+
+Stricter parsing of `for`/`in`.
+
+Don't allow unicode escapes in contextual keywords.
+
+### New features
+
+Parsing class members was factored into smaller methods to allow plugins to hook into it.
+
+## 5.2.1 (2017-10-30)
+
+### Bug fixes
+
+Fix a token context corruption bug.
+
+## 5.2.0 (2017-10-30)
+
+### Bug fixes
+
+Fix token context tracking for `class` and `function` in property-name position.
+
+Make sure `%*` isn't parsed as a valid operator.
+
+Allow shorthand properties `get` and `set` to be followed by default values.
+
+Disallow `super` when not in callee or object position.
+
+### New features
+
+Support [`directive` property](https://github.com/estree/estree/compare/b3de58c9997504d6fba04b72f76e6dd1619ee4eb...1da8e603237144f44710360f8feb7a9977e905e0) on directive expression statements.
+
+## 5.1.2 (2017-09-04)
+
+### Bug fixes
+
+Disable parsing of legacy HTML-style comments in modules.
+
+Fix parsing of async methods whose names are keywords.
+
+## 5.1.1 (2017-07-06)
+
+### Bug fixes
+
+Fix problem with disambiguating regexp and division after a class.
+
+## 5.1.0 (2017-07-05)
+
+### Bug fixes
+
+Fix tokenizing of regexps in an object-desctructuring `for`/`of` loop and after `yield`.
+
+Parse zero-prefixed numbers with non-octal digits as decimal.
+
+Allow object/array patterns in rest parameters.
+
+Don't error when `yield` is used as a property name.
+
+Allow `async` as a shorthand object property.
+
+### New features
+
+Implement the [template literal revision proposal](https://github.com/tc39/proposal-template-literal-revision) for ES9.
+
+## 5.0.3 (2017-04-01)
+
+### Bug fixes
+
+Fix spurious duplicate variable definition errors for named functions.
+
+## 5.0.2 (2017-03-30)
+
+### Bug fixes
+
+A binary operator after a parenthesized arrow expression is no longer incorrectly treated as an error.
+
+## 5.0.0 (2017-03-28)
+
+### Bug fixes
+
+Raise an error for duplicated lexical bindings.
+
+Fix spurious error when an assignement expression occurred after a spread expression.
+
+Accept regular expressions after `of` (in `for`/`of`), `yield` (in a generator), and braced arrow functions.
+
+Allow labels in front or `var` declarations, even in strict mode.
+
+### Breaking changes
+
+Parse declarations following `export default` as declaration nodes, not expressions. This means that class and function declarations nodes can now have `null` as their `id`.
+
+## 4.0.11 (2017-02-07)
+
+### Bug fixes
+
+Allow all forms of member expressions to be parenthesized as lvalue.
+
+## 4.0.10 (2017-02-07)
+
+### Bug fixes
+
+Don't expect semicolons after default-exported functions or classes, even when they are expressions.
+
+Check for use of `'use strict'` directives in non-simple parameter functions, even when already in strict mode.
+
+## 4.0.9 (2017-02-06)
+
+### Bug fixes
+
+Fix incorrect error raised for parenthesized simple assignment targets, so that `(x) = 1` parses again.
+
+## 4.0.8 (2017-02-03)
+
+### Bug fixes
+
+Solve spurious parenthesized pattern errors by temporarily erring on the side of accepting programs that our delayed errors don't handle correctly yet.
+
+## 4.0.7 (2017-02-02)
+
+### Bug fixes
+
+Accept invalidly rejected code like `(x).y = 2` again.
+
+Don't raise an error when a function _inside_ strict code has a non-simple parameter list.
+
+## 4.0.6 (2017-02-02)
+
+### Bug fixes
+
+Fix exponential behavior (manifesting itself as a complete hang for even relatively small source files) introduced by the new 'use strict' check.
+
+## 4.0.5 (2017-02-02)
+
+### Bug fixes
+
+Disallow parenthesized pattern expressions.
+
+Allow keywords as export names.
+
+Don't allow the `async` keyword to be parenthesized.
+
+Properly raise an error when a keyword contains a character escape.
+
+Allow `"use strict"` to appear after other string literal expressions.
+
+Disallow labeled declarations.
+
+## 4.0.4 (2016-12-19)
+
+### Bug fixes
+
+Fix crash when `export` was followed by a keyword that can't be
+exported.
+
+## 4.0.3 (2016-08-16)
+
+### Bug fixes
+
+Allow regular function declarations inside single-statement `if` branches in loose mode. Forbid them entirely in strict mode.
+
+Properly parse properties named `async` in ES2017 mode.
+
+Fix bug where reserved words were broken in ES2017 mode.
+
+## 4.0.2 (2016-08-11)
+
+### Bug fixes
+
+Don't ignore period or 'e' characters after octal numbers.
+
+Fix broken parsing for call expressions in default parameter values of arrow functions.
+
+## 4.0.1 (2016-08-08)
+
+### Bug fixes
+
+Fix false positives in duplicated export name errors.
+
+## 4.0.0 (2016-08-07)
+
+### Breaking changes
+
+The default `ecmaVersion` option value is now 7.
+
+A number of internal method signatures changed, so plugins might need to be updated.
+
+### Bug fixes
+
+The parser now raises errors on duplicated export names.
+
+`arguments` and `eval` can now be used in shorthand properties.
+
+Duplicate parameter names in non-simple argument lists now always produce an error.
+
+### New features
+
+The `ecmaVersion` option now also accepts year-style version numbers
+(2015, etc).
+
+Support for `async`/`await` syntax when `ecmaVersion` is >= 8.
+
+Support for trailing commas in call expressions when `ecmaVersion` is >= 8.
+
+## 3.3.0 (2016-07-25)
+
+### Bug fixes
+
+Fix bug in tokenizing of regexp operator after a function declaration.
+
+Fix parser crash when parsing an array pattern with a hole.
+
+### New features
+
+Implement check against complex argument lists in functions that enable strict mode in ES7.
+
+## 3.2.0 (2016-06-07)
+
+### Bug fixes
+
+Improve handling of lack of unicode regexp support in host
+environment.
+
+Properly reject shorthand properties whose name is a keyword.
+
+### New features
+
+Visitors created with `visit.make` now have their base as _prototype_, rather than copying properties into a fresh object.
+
+## 3.1.0 (2016-04-18)
+
+### Bug fixes
+
+Properly tokenize the division operator directly after a function expression.
+
+Allow trailing comma in destructuring arrays.
+
+## 3.0.4 (2016-02-25)
+
+### Fixes
+
+Allow update expressions as left-hand-side of the ES7 exponential operator.
+
+## 3.0.2 (2016-02-10)
+
+### Fixes
+
+Fix bug that accidentally made `undefined` a reserved word when parsing ES7.
+
+## 3.0.0 (2016-02-10)
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 6 (used to be 5).
+
+Support for comprehension syntax (which was dropped from the draft spec) has been removed.
+
+### Fixes
+
+`let` and `yield` are now “contextual keywords”, meaning you can mostly use them as identifiers in ES5 non-strict code.
+
+A parenthesized class or function expression after `export default` is now parsed correctly.
+
+### New features
+
+When `ecmaVersion` is set to 7, Acorn will parse the exponentiation operator (`**`).
+
+The identifier character ranges are now based on Unicode 8.0.0.
+
+Plugins can now override the `raiseRecoverable` method to override the way non-critical errors are handled.
+
+## 2.7.0 (2016-01-04)
+
+### Fixes
+
+Stop allowing rest parameters in setters.
+
+Disallow `y` rexexp flag in ES5.
+
+Disallow `\00` and `\000` escapes in strict mode.
+
+Raise an error when an import name is a reserved word.
+
+## 2.6.2 (2015-11-10)
+
+### Fixes
+
+Don't crash when no options object is passed.
+
+## 2.6.0 (2015-11-09)
+
+### Fixes
+
+Add `await` as a reserved word in module sources.
+
+Disallow `yield` in a parameter default value for a generator.
+
+Forbid using a comma after a rest pattern in an array destructuring.
+
+### New features
+
+Support parsing stdin in command-line tool.
+
+## 2.5.0 (2015-10-27)
+
+### Fixes
+
+Fix tokenizer support in the command-line tool.
+
+Stop allowing `new.target` outside of functions.
+
+Remove legacy `guard` and `guardedHandler` properties from try nodes.
+
+Stop allowing multiple `__proto__` properties on an object literal in strict mode.
+
+Don't allow rest parameters to be non-identifier patterns.
+
+Check for duplicate paramter names in arrow functions.

node_modules/@vue/cli-service/node_modules/acorn/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2018 by various contributors (see AUTHORS)
+
+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.

node_modules/@vue/cli-service/node_modules/acorn/README.md

@@ -0,0 +1,269 @@
+# Acorn
+
+A tiny, fast JavaScript parser written in JavaScript.
+
+## Community
+
+Acorn is open source software released under an
+[MIT license](https://github.com/acornjs/acorn/blob/master/acorn/LICENSE).
+
+You are welcome to
+[report bugs](https://github.com/acornjs/acorn/issues) or create pull
+requests on [github](https://github.com/acornjs/acorn). For questions
+and discussion, please use the
+[Tern discussion forum](https://discuss.ternjs.net).
+
+## Installation
+
+The easiest way to install acorn is from [`npm`](https://www.npmjs.com/):
+
+```sh
+npm install acorn
+```
+
+Alternately, you can download the source and build acorn yourself:
+
+```sh
+git clone https://github.com/acornjs/acorn.git
+cd acorn
+npm install
+```
+
+## Interface
+
+**parse**`(input, options)` is the main interface to the library. The
+`input` parameter is a string, `options` can be undefined or an object
+setting some of the options listed below. The return value will be an
+abstract syntax tree object as specified by the [ESTree
+spec](https://github.com/estree/estree).
+
+```javascript
+let acorn = require("acorn");
+console.log(acorn.parse("1 + 1"));
+```
+
+When encountering a syntax error, the parser will raise a
+`SyntaxError` object with a meaningful message. The error object will
+have a `pos` property that indicates the string offset at which the
+error occurred, and a `loc` object that contains a `{line, column}`
+object referring to that same position.
+
+Options can be provided by passing a second argument, which should be
+an object containing any of these fields:
+
+- **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
+  either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018) or 10 (2019, partial
+  support). This influences support for strict mode, the set of
+  reserved words, and support for new syntax features. Default is 7.
+
+  **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being
+  implemented by Acorn. Other proposed new features can be implemented
+  through plugins.
+
+- **sourceType**: Indicate the mode the code should be parsed in. Can be
+  either `"script"` or `"module"`. This influences global strict mode
+  and parsing of `import` and `export` declarations.
+
+- **onInsertedSemicolon**: If given a callback, that callback will be
+  called whenever a missing semicolon is inserted by the parser. The
+  callback will be given the character offset of the point where the
+  semicolon is inserted as argument, and if `locations` is on, also a
+  `{line, column}` object representing this position.
+
+- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
+  commas.
+
+- **allowReserved**: If `false`, using a reserved word will generate
+  an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher
+  versions. When given the value `"never"`, reserved words and
+  keywords can also not be used as property names (as in Internet
+  Explorer's old parser).
+
+- **allowReturnOutsideFunction**: By default, a return statement at
+  the top level raises an error. Set this to `true` to accept such
+  code.
+
+- **allowImportExportEverywhere**: By default, `import` and `export`
+  declarations can only appear at a program's top level. Setting this
+  option to `true` allows them anywhere where a statement is allowed.
+  
+- **allowAwaitOutsideFunction**: By default, `await` expressions can
+  only appear inside `async` functions. Setting this option to
+  `true` allows to have top-level `await` expressions. They are
+  still not allowed in non-`async` functions, though.
+
+- **allowHashBang**: When this is enabled (off by default), if the
+  code starts with the characters `#!` (as in a shellscript), the
+  first line will be treated as a comment.
+
+- **locations**: When `true`, each node has a `loc` object attached
+  with `start` and `end` subobjects, each of which contains the
+  one-based line and zero-based column numbers in `{line, column}`
+  form. Default is `false`.
+
+- **onToken**: If a function is passed for this option, each found
+  token will be passed in same format as tokens returned from
+  `tokenizer().getToken()`.
+
+  If array is passed, each found token is pushed to it.
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **onComment**: If a function is passed for this option, whenever a
+  comment is encountered the function will be called with the
+  following parameters:
+
+  - `block`: `true` if the comment is a block comment, false if it
+    is a line comment.
+  - `text`: The content of the comment.
+  - `start`: Character offset of the start of the comment.
+  - `end`: Character offset of the end of the comment.
+
+  When the `locations` options is on, the `{line, column}` locations
+  of the comment’s start and end are passed as two additional
+  parameters.
+
+  If array is passed for this option, each found comment is pushed
+  to it as object in Esprima format:
+
+  ```javascript
+  {
+    "type": "Line" | "Block",
+    "value": "comment text",
+    "start": Number,
+    "end": Number,
+    // If `locations` option is on:
+    "loc": {
+      "start": {line: Number, column: Number}
+      "end": {line: Number, column: Number}
+    },
+    // If `ranges` option is on:
+    "range": [Number, Number]
+  }
+  ```
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **ranges**: Nodes have their start and end characters offsets
+  recorded in `start` and `end` properties (directly on the node,
+  rather than the `loc` object, which holds line/column data. To also
+  add a
+  [semi-standardized](https://bugzilla.mozilla.org/show_bug.cgi?id=745678)
+  `range` property holding a `[start, end]` array with the same
+  numbers, set the `ranges` option to `true`.
+
+- **program**: It is possible to parse multiple files into a single
+  AST by passing the tree produced by parsing the first file as the
+  `program` option in subsequent parses. This will add the toplevel
+  forms of the parsed file to the "Program" (top) node of an existing
+  parse tree.
+
+- **sourceFile**: When the `locations` option is `true`, you can pass
+  this option to add a `source` attribute in every node’s `loc`
+  object. Note that the contents of this option are not examined or
+  processed in any way; you are free to use whatever format you
+  choose.
+
+- **directSourceFile**: Like `sourceFile`, but a `sourceFile` property
+  will be added (regardless of the `location` option) directly to the
+  nodes, rather than the `loc` object.
+
+- **preserveParens**: If this option is `true`, parenthesized expressions
+  are represented by (non-standard) `ParenthesizedExpression` nodes
+  that have a single `expression` property containing the expression
+  inside parentheses.
+
+**parseExpressionAt**`(input, offset, options)` will parse a single
+expression in a string, and return its AST. It will not complain if
+there is more of the string left after the expression.
+
+**tokenizer**`(input, options)` returns an object with a `getToken`
+method that can be called repeatedly to get the next token, a `{start,
+end, type, value}` object (with added `loc` property when the
+`locations` option is enabled and `range` property when the `ranges`
+option is enabled). When the token's type is `tokTypes.eof`, you
+should stop calling the method, since it will keep returning that same
+token forever.
+
+In ES6 environment, returned result can be used as any other
+protocol-compliant iterable:
+
+```javascript
+for (let token of acorn.tokenizer(str)) {
+  // iterate over the tokens
+}
+
+// transform code to array of tokens:
+var tokens = [...acorn.tokenizer(str)];
+```
+
+**tokTypes** holds an object mapping names to the token type objects
+that end up in the `type` properties of tokens.
+
+**getLineInfo**`(input, offset)` can be used to get a `{line,
+column}` object for a given program string and offset.
+
+### The `Parser` class
+
+Instances of the **`Parser`** class contain all the state and logic
+that drives a parse. It has static methods `parse`,
+`parseExpressionAt`, and `tokenizer` that match the top-level
+functions by the same name.
+
+When extending the parser with plugins, you need to call these methods
+on the extended version of the class. To extend a parser with plugins,
+you can use its static `extend` method.
+
+```javascript
+var acorn = require("acorn");
+var jsx = require("acorn-jsx");
+var JSXParser = acorn.Parser.extend(jsx());
+JSXParser.parse("foo(<bar/>)");
+```
+
+The `extend` method takes any number of plugin values, and returns a
+new `Parser` class that includes the extra parser logic provided by
+the plugins.
+
+## Command line interface
+
+The `bin/acorn` utility can be used to parse a file from the command
+line. It accepts as arguments its input file and the following
+options:
+
+- `--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|--ecma10`: Sets the ECMAScript version
+  to parse. Default is version 9.
+
+- `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise.
+
+- `--locations`: Attaches a "loc" object to each node with "start" and
+  "end" subobjects, each of which contains the one-based line and
+  zero-based column numbers in `{line, column}` form.
+
+- `--allow-hash-bang`: If the code starts with the characters #! (as
+  in a shellscript), the first line will be treated as a comment.
+
+- `--compact`: No whitespace is used in the AST output.
+
+- `--silent`: Do not output the AST, just return the exit status.
+
+- `--help`: Print the usage information and quit.
+
+The utility spits out the syntax tree as JSON data.
+
+## Existing plugins
+
+ - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx)
+ 
+Plugins for ECMAScript proposals:
+ 
+ - [`acorn-stage3`](https://github.com/acornjs/acorn-stage3): Parse most stage 3 proposals, bundling:
+   - [`acorn-async-iteration`](https://github.com/acornjs/acorn-async-iteration): Parse [async iteration proposal](https://github.com/tc39/proposal-async-iteration)
+   - [`acorn-bigint`](https://github.com/acornjs/acorn-bigint): Parse [BigInt proposal](https://github.com/tc39/proposal-bigint)
+   - [`acorn-class-fields`](https://github.com/acornjs/acorn-class-fields): Parse [class fields proposal](https://github.com/tc39/proposal-class-fields)
+   - [`acorn-dynamic-import`](https://github.com/kesne/acorn-dynamic-import): Parse [import() proposal](https://github.com/tc39/proposal-dynamic-import)
+   - [`acorn-import-meta`](https://github.com/acornjs/acorn-import-meta): Parse [import.meta proposal](https://github.com/tc39/proposal-import-meta)
+   - [`acorn-numeric-separator`](https://github.com/acornjs/acorn-numeric-separator): Parse [numeric separator proposal](https://github.com/tc39/proposal-numeric-separator)
+   - [`acorn-private-methods`](https://github.com/acornjs/acorn-private-methods): parse [private methods, getters and setters proposal](https://github.com/tc39/proposal-private-methods)n

node_modules/@vue/cli-service/node_modules/acorn/bin/acorn

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../dist/bin.js');

node_modules/@vue/cli-service/node_modules/acorn/dist/acorn.d.ts

@@ -0,0 +1,209 @@
+export as namespace acorn
+export = acorn
+
+declare namespace acorn {
+  function parse(input: string, options?: Options): Node
+
+  function parseExpressionAt(input: string, pos?: number, options?: Options): Node
+
+  function tokenizer(input: string, options?: Options): {
+    getToken(): Token
+    [Symbol.iterator](): Iterator<Token>
+  }
+
+  interface Options {
+    ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 9 | 10 | 2015 | 2016 | 2017 | 2018 | 2019
+    sourceType?: 'script' | 'module'
+    onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    allowReserved?: boolean
+    allowReturnOutsideFunction?: boolean
+    allowImportExportEverywhere?: boolean
+    allowAwaitOutsideFunction?: boolean
+    allowHashBang?: boolean
+    locations?: boolean
+    onToken?: ((token: Token) => any) | Token[]
+    onComment?: ((
+      isBlock: boolean, text: string, start: number, end: number, startLoc?: Position,
+      endLoc?: Position
+    ) => void) | Comment[]
+    ranges?: boolean
+    program?: Node
+    sourceFile?: string
+    directSourceFile?: string
+    preserveParens?: boolean
+  }
+
+  class Parser {
+    constructor(options: Options, input: string, startPos?: number)
+    parse(): Node
+    static parse(input: string, options?: Options): Node
+    static parseExpressionAt(input: string, pos: number, options?: Options): Node
+    static tokenizer(input: string, options?: Options): {
+      getToken(): Token
+      [Symbol.iterator](): Iterator<Token>
+    }
+    static extend(...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser
+  }
+
+  interface Position { line: number; column: number; offset: number }
+
+  const defaultOptions: Options
+
+  function getLineInfo(input: string, offset: number): Position
+
+  class SourceLocation {
+    start: Position
+    end: Position
+    source?: string | null
+    constructor(p: Parser, start: Position, end: Position)
+  }
+
+  class Node {
+    type: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    sourceFile?: string
+    range?: [number, number]
+    constructor(parser: Parser, pos: number, loc?: SourceLocation)
+  }
+
+  class TokenType {
+    label: string
+    keyword: string
+    beforeExpr: boolean
+    startsExpr: boolean
+    isLoop: boolean
+    isAssign: boolean
+    prefix: boolean
+    postfix: boolean
+    binop: number
+    updateContext?: (prevType: TokenType) => void
+    constructor(label: string, conf?: any)
+  }
+
+  const tokTypes: {
+    num: TokenType
+    regexp: TokenType
+    string: TokenType
+    name: TokenType
+    eof: TokenType
+    bracketL: TokenType
+    bracketR: TokenType
+    braceL: TokenType
+    braceR: TokenType
+    parenL: TokenType
+    parenR: TokenType
+    comma: TokenType
+    semi: TokenType
+    colon: TokenType
+    dot: TokenType
+    question: TokenType
+    arrow: TokenType
+    template: TokenType
+    ellipsis: TokenType
+    backQuote: TokenType
+    dollarBraceL: TokenType
+    eq: TokenType
+    assign: TokenType
+    incDec: TokenType
+    prefix: TokenType
+    logicalOR: TokenType
+    logicalAND: TokenType
+    bitwiseOR: TokenType
+    bitwiseXOR: TokenType
+    bitwiseAND: TokenType
+    equality: TokenType
+    relational: TokenType
+    bitShift: TokenType
+    plusMin: TokenType
+    modulo: TokenType
+    star: TokenType
+    slash: TokenType
+    starstar: TokenType
+    _break: TokenType
+    _case: TokenType
+    _catch: TokenType
+    _continue: TokenType
+    _debugger: TokenType
+    _default: TokenType
+    _do: TokenType
+    _else: TokenType
+    _finally: TokenType
+    _for: TokenType
+    _function: TokenType
+    _if: TokenType
+    _return: TokenType
+    _switch: TokenType
+    _throw: TokenType
+    _try: TokenType
+    _var: TokenType
+    _const: TokenType
+    _while: TokenType
+    _with: TokenType
+    _new: TokenType
+    _this: TokenType
+    _super: TokenType
+    _class: TokenType
+    _extends: TokenType
+    _export: TokenType
+    _import: TokenType
+    _null: TokenType
+    _true: TokenType
+    _false: TokenType
+    _in: TokenType
+    _instanceof: TokenType
+    _typeof: TokenType
+    _void: TokenType
+    _delete: TokenType
+  }
+
+  class TokContext {
+    constructor(token: string, isExpr: boolean, preserveSpace: boolean, override?: (p: Parser) => void)
+  }
+
+  const tokContexts: {
+    b_stat: TokContext
+    b_expr: TokContext
+    b_tmpl: TokContext
+    p_stat: TokContext
+    p_expr: TokContext
+    q_tmpl: TokContext
+    f_expr: TokContext
+  }
+
+  function isIdentifierStart(code: number, astral?: boolean): boolean
+
+  function isIdentifierChar(code: number, astral?: boolean): boolean
+
+  interface AbstractToken {
+  }
+
+  interface Comment extends AbstractToken {
+    type: string
+    value: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+  }
+
+  class Token {
+    type: TokenType
+    value: any
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+    constructor(p: Parser)
+  }
+
+  function isNewLine(code: number): boolean
+
+  const lineBreak: RegExp
+
+  const lineBreakG: RegExp
+
+  const version: string
+}

node_modules/@vue/cli-service/node_modules/acorn/dist/bin.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var acorn = require('./acorn.js');
+
+var infile;
+var forceFile;
+var silent = false;
+var compact = false;
+var tokenize = false;
+var options = {};
+
+function help(status) {
+  var print = (status === 0) ? console.log : console.error;
+  print("usage: " + path.basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|...|--ecma2015|--ecma2016|--ecma2017|--ecma2018|...]");
+  print("        [--tokenize] [--locations] [---allow-hash-bang] [--compact] [--silent] [--module] [--help] [--] [infile]");
+  process.exit(status);
+}
+
+for (var i = 2; i < process.argv.length; ++i) {
+  var arg = process.argv[i];
+  if ((arg === "-" || arg[0] !== "-") && !infile) { infile = arg; }
+  else if (arg === "--" && !infile && i + 2 === process.argv.length) { forceFile = infile = process.argv[++i]; }
+  else if (arg === "--locations") { options.locations = true; }
+  else if (arg === "--allow-hash-bang") { options.allowHashBang = true; }
+  else if (arg === "--silent") { silent = true; }
+  else if (arg === "--compact") { compact = true; }
+  else if (arg === "--help") { help(0); }
+  else if (arg === "--tokenize") { tokenize = true; }
+  else if (arg === "--module") { options.sourceType = "module"; }
+  else {
+    var match = arg.match(/^--ecma(\d+)$/);
+    if (match)
+      { options.ecmaVersion = +match[1]; }
+    else
+      { help(1); }
+  }
+}
+
+function run(code) {
+  var result;
+  try {
+    if (!tokenize) {
+      result = acorn.parse(code, options);
+    } else {
+      result = [];
+      var tokenizer$$1 = acorn.tokenizer(code, options), token;
+      do {
+        token = tokenizer$$1.getToken();
+        result.push(token);
+      } while (token.type !== acorn.tokTypes.eof)
+    }
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+  if (!silent) { console.log(JSON.stringify(result, null, compact ? null : 2)); }
+}
+
+if (forceFile || infile && infile !== "-") {
+  run(fs.readFileSync(infile, "utf8"));
+} else {
+  var code = "";
+  process.stdin.resume();
+  process.stdin.on("data", function (chunk) { return code += chunk; });
+  process.stdin.on("end", function () { return run(code); });
+}

node_modules/@vue/cli-service/node_modules/acorn/package.json

@@ -0,0 +1,66 @@
+{
+  "_from": "acorn@^6.1.0",
+  "_id": "acorn@6.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-jPTiwtOxaHNaAPg/dmrJ/beuzLRnXtB0kQPQ8JpotKJgTB6rX6c8mlf315941pyjBSaPg8NHXS9fhP4u17DpGA==",
+  "_location": "/@vue/cli-service/acorn",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "acorn@^6.1.0",
+    "name": "acorn",
+    "escapedName": "acorn",
+    "rawSpec": "^6.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^6.1.0"
+  },
+  "_requiredBy": [
+    "/@vue/cli-service"
+  ],
+  "_resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.1.tgz",
+  "_shasum": "7d25ae05bb8ad1f9b699108e1094ecd7884adc1f",
+  "_spec": "acorn@^6.1.0",
+  "_where": "D:\\Atom\\Git\\Laravel_CSSd\\node_modules\\@vue\\cli-service",
+  "bin": {
+    "acorn": "./bin/acorn"
+  },
+  "bugs": {
+    "url": "https://github.com/acornjs/acorn/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "ECMAScript parser",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "homepage": "https://github.com/acornjs/acorn",
+  "license": "MIT",
+  "main": "dist/acorn.js",
+  "maintainers": [
+    {
+      "name": "Marijn Haverbeke",
+      "email": "marijnh@gmail.com",
+      "url": "https://marijnhaverbeke.nl"
+    },
+    {
+      "name": "Ingvar Stepanyan",
+      "email": "me@rreverser.com",
+      "url": "https://rreverser.com/"
+    },
+    {
+      "name": "Adrian Heine",
+      "url": "http://adrianheine.de"
+    }
+  ],
+  "module": "dist/acorn.mjs",
+  "name": "acorn",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acornjs/acorn.git"
+  },
+  "scripts": {
+    "prepare": "cd ..; npm run build:main && npm run build:bin"
+  },
+  "version": "6.1.1"
+}

node_modules/@vue/cli-service/node_modules/css-loader/CHANGELOG.md

@@ -0,0 +1,190 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="1.0.1"></a>
+## [1.0.1](https://github.com/webpack-contrib/css-loader/compare/v1.0.0...v1.0.1) (2018-10-29)
+
+
+### Bug Fixes
+
+* **loader:** trim unquoted import urls ([#783](https://github.com/webpack-contrib/css-loader/issues/783)) ([21fcddf](https://github.com/webpack-contrib/css-loader/commit/21fcddf))
+
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/webpack-contrib/css-loader/compare/v0.28.11...v1.0.0) (2018-07-06)
+
+
+### BREAKING CHANGES
+
+* remove `minimize` option, use [`postcss-loader`](https://github.com/postcss/postcss-loader) with [`cssnano`](https://github.com/cssnano/cssnano) or use [`optimize-cssnano-plugin`](https://github.com/intervolga/optimize-cssnano-plugin) plugin
+* remove `module` option, use `modules` option instead
+* remove `camelcase` option, use `camelCase` option instead
+* remove `root` option, use [`postcss-loader`](https://github.com/postcss/postcss-loader) with [`postcss-url`](https://github.com/postcss/postcss-url) plugin
+* remove `alias` option, use [`resolve.alias`](https://webpack.js.org/configuration/resolve/) feature or use [`postcss-loader`](https://github.com/postcss/postcss-loader) with [`postcss-url`](https://github.com/postcss/postcss-url) plugin
+* update `postcss` to `6` version
+* minimum require `nodejs` version is `6.9`
+* minimum require `webpack` version is `4`
+
+
+
+<a name="0.28.11"></a>
+## [0.28.11](https://github.com/webpack-contrib/css-loader/compare/v0.28.10...v0.28.11) (2018-03-16)
+
+
+### Bug Fixes
+
+* **lib/processCss:** don't check `mode` for `url` handling (`options.modules`) ([#698](https://github.com/webpack-contrib/css-loader/issues/698)) ([c788450](https://github.com/webpack-contrib/css-loader/commit/c788450))
+
+
+
+<a name="0.28.10"></a>
+## [0.28.10](https://github.com/webpack-contrib/css-loader/compare/v0.28.9...v0.28.10) (2018-02-22)
+
+
+### Bug Fixes
+
+* **getLocalIdent:** add `rootContext` support (`webpack >= v4.0.0`) ([#681](https://github.com/webpack-contrib/css-loader/issues/681)) ([9f876d2](https://github.com/webpack-contrib/css-loader/commit/9f876d2))
+
+
+
+<a name="0.28.9"></a>
+## [0.28.9](https://github.com/webpack-contrib/css-loader/compare/v0.28.8...v0.28.9) (2018-01-17)
+
+
+### Bug Fixes
+
+* ignore invalid URLs (`url()`) ([#663](https://github.com/webpack-contrib/css-loader/issues/663)) ([d1d8221](https://github.com/webpack-contrib/css-loader/commit/d1d8221))
+
+
+
+<a name="0.28.8"></a>
+## [0.28.8](https://github.com/webpack-contrib/css-loader/compare/v0.28.7...v0.28.8) (2018-01-05)
+
+
+### Bug Fixes
+
+* **loader:** correctly check if source map is `undefined` ([#641](https://github.com/webpack-contrib/css-loader/issues/641)) ([0dccfa9](https://github.com/webpack-contrib/css-loader/commit/0dccfa9))
+* proper URL escaping and wrapping (`url()`) ([#627](https://github.com/webpack-contrib/css-loader/issues/627)) ([8897d44](https://github.com/webpack-contrib/css-loader/commit/8897d44))
+
+
+
+<a name="0.28.7"></a>
+## [0.28.7](https://github.com/webpack/css-loader/compare/v0.28.6...v0.28.7) (2017-08-30)
+
+
+### Bug Fixes
+
+* pass resolver to `localsLoader` (`options.alias`)  ([#601](https://github.com/webpack/css-loader/issues/601)) ([8f1b57c](https://github.com/webpack/css-loader/commit/8f1b57c))
+
+
+
+<a name="0.28.6"></a>
+## [0.28.6](https://github.com/webpack/css-loader/compare/v0.28.5...v0.28.6) (2017-08-30)
+
+
+### Bug Fixes
+
+* add support for aliases starting with `/` (`options.alias`) ([#597](https://github.com/webpack/css-loader/issues/597)) ([63567f2](https://github.com/webpack/css-loader/commit/63567f2))
+
+
+
+<a name="0.28.5"></a>
+## [0.28.5](https://github.com/webpack/css-loader/compare/v0.28.4...v0.28.5) (2017-08-17)
+
+
+### Bug Fixes
+
+* match mutliple dashes (`options.camelCase`) ([#556](https://github.com/webpack/css-loader/issues/556)) ([1fee601](https://github.com/webpack/css-loader/commit/1fee601))
+* stricter `[@import](https://github.com/import)` tolerance ([#593](https://github.com/webpack/css-loader/issues/593)) ([2e4ec09](https://github.com/webpack/css-loader/commit/2e4ec09))
+
+
+
+<a name="0.28.4"></a>
+## [0.28.4](https://github.com/webpack/css-loader/compare/v0.28.3...v0.28.4) (2017-05-30)
+
+
+### Bug Fixes
+
+* preserve leading underscore in class names ([#543](https://github.com/webpack/css-loader/issues/543)) ([f6673c8](https://github.com/webpack/css-loader/commit/f6673c8))
+
+
+
+<a name="0.28.3"></a>
+## [0.28.3](https://github.com/webpack/css-loader/compare/v0.28.2...v0.28.3) (2017-05-25)
+
+
+### Bug Fixes
+
+* correct plugin order for CSS Modules ([#534](https://github.com/webpack/css-loader/issues/534)) ([b90f492](https://github.com/webpack/css-loader/commit/b90f492))
+
+
+
+<a name="0.28.2"></a>
+## [0.28.2](https://github.com/webpack/css-loader/compare/v0.28.1...v0.28.2) (2017-05-22)
+
+
+### Bug Fixes
+
+* source maps path on `windows` ([#532](https://github.com/webpack/css-loader/issues/532)) ([c3d0d91](https://github.com/webpack/css-loader/commit/c3d0d91))
+
+
+
+<a name="0.28.1"></a>
+## [0.28.1](https://github.com/webpack/css-loader/compare/v0.28.0...v0.28.1) (2017-05-02)
+
+
+### Bug Fixes
+
+* allow to specify a full hostname as a root URL ([#521](https://github.com/webpack/css-loader/issues/521)) ([06d27a1](https://github.com/webpack/css-loader/commit/06d27a1))
+* case insensitivity of [@import](https://github.com/import) ([#514](https://github.com/webpack/css-loader/issues/514)) ([de4356b](https://github.com/webpack/css-loader/commit/de4356b))
+* don't handle empty [@import](https://github.com/import) and url() ([#513](https://github.com/webpack/css-loader/issues/513)) ([868fc94](https://github.com/webpack/css-loader/commit/868fc94))
+* imported variables are replaced in exports if followed by a comma ([#504](https://github.com/webpack/css-loader/issues/504)) ([956bad7](https://github.com/webpack/css-loader/commit/956bad7))
+* loader now correctly handles `url` with space(s) ([#495](https://github.com/webpack/css-loader/issues/495)) ([534ea55](https://github.com/webpack/css-loader/commit/534ea55))
+* url with a trailing space is now handled correctly ([#494](https://github.com/webpack/css-loader/issues/494)) ([e1ec4f2](https://github.com/webpack/css-loader/commit/e1ec4f2))
+* use `btoa` instead `Buffer` ([#501](https://github.com/webpack/css-loader/issues/501)) ([fbb0714](https://github.com/webpack/css-loader/commit/fbb0714))
+
+
+### Performance Improvements
+
+* generate source maps only when explicitly set ([#478](https://github.com/webpack/css-loader/issues/478)) ([b8f5c8f](https://github.com/webpack/css-loader/commit/b8f5c8f))
+
+
+
+<a name="0.28.0"></a>
+# [0.28.0](https://github.com/webpack/css-loader/compare/v0.27.3...v0.28.0) (2017-03-30)
+
+
+### Features
+
+* add alias feature to rewrite URLs ([#274](https://github.com/webpack/css-loader/issues/274)) ([c8db489](https://github.com/webpack/css-loader/commit/c8db489))
+
+
+
+<a name="0.27.3"></a>
+## [0.27.3](https://github.com/webpack/css-loader/compare/v0.27.2...v0.27.3) (2017-03-13)
+
+
+
+<a name="0.27.2"></a>
+# [0.27.2](https://github.com/webpack/css-loader/compare/v0.27.1...v0.27.2) (2017-03-12)
+
+<a name="0.27.1"></a>
+# [0.27.1](https://github.com/webpack/css-loader/compare/v0.27.0...v0.27.1) (2017-03-10)
+
+<a name="0.27.0"></a>
+# [0.27.0](https://github.com/webpack/css-loader/compare/v0.26.2...v0.27.0) (2017-03-10)
+
+
+### Bug Fixes
+
+* **sourcemaps:** use abs paths & remove sourceRoot ([c769ac3](https://github.com/webpack/css-loader/commit/c769ac3))
+* `minimizeOptions` should be `query.minimize`! ([16c0858](https://github.com/webpack/css-loader/commit/16c0858))
+* do not export duplicate keys ([#420](https://github.com/webpack/css-loader/issues/420)) ([a2b85d7](https://github.com/webpack/css-loader/commit/a2b85d7))
+
+
+### Features
+
+* allow removal of original class name ([#445](https://github.com/webpack/css-loader/issues/445)) ([3f78361](https://github.com/webpack/css-loader/commit/3f78361))
+* Include the sourceMappingURL & sourceURL when toString() ([6da7e90](https://github.com/webpack/css-loader/commit/6da7e90))

node_modules/@vue/cli-service/node_modules/css-loader/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+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.

node_modules/@vue/cli-service/node_modules/css-loader/README.md

@@ -0,0 +1,454 @@
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+
+<div align="center">
+  <img width="180" height="180" vspace="20"
+    src="https://cdn.worldvectorlogo.com/logos/css-3.svg">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+  <h1>CSS Loader</h1>
+</div>
+
+<h2 align="center">Install</h2>
+
+```bash
+npm install --save-dev css-loader
+```
+
+<h2 align="center">Usage</h2>
+
+The `css-loader` interprets `@import` and `url()` like `import/require()`
+and will resolve them.
+
+Good loaders for requiring your assets are the [file-loader](https://github.com/webpack/file-loader)
+and the [url-loader](https://github.com/webpack/url-loader) which you should specify in your config (see [below](https://github.com/webpack-contrib/css-loader#assets)).
+
+**file.js**
+```js
+import css from 'file.css';
+```
+
+**webpack.config.js**
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        use: [ 'style-loader', 'css-loader' ]
+      }
+    ]
+  }
+}
+```
+
+### `toString`
+
+You can also use the css-loader results directly as a string, such as in Angular's component style.
+
+**webpack.config.js**
+```js
+{
+   test: /\.css$/,
+   use: [
+     'to-string-loader',
+     'css-loader'
+   ]
+}
+```
+
+or
+
+```js
+const css = require('./test.css').toString();
+
+console.log(css); // {String}
+```
+
+If there are SourceMaps, they will also be included in the result string.
+
+If, for one reason or another, you need to extract CSS as a
+plain string resource (i.e. not wrapped in a JS module) you
+might want to check out the [extract-loader](https://github.com/peerigon/extract-loader).
+It's useful when you, for instance, need to post process the CSS as a string.
+
+**webpack.config.js**
+```js
+{
+   test: /\.css$/,
+   use: [
+     'handlebars-loader', // handlebars loader expects raw resource string
+     'extract-loader',
+     'css-loader'
+   ]
+}
+```
+
+<h2 align="center">Options</h2>
+
+|Name|Type|Default|Description|
+|:--:|:--:|:-----:|:----------|
+|**[`url`](#url)**|`{Boolean}`|`true`| Enable/Disable `url()` handling|
+|**[`import`](#import)** |`{Boolean}`|`true`| Enable/Disable @import handling|
+|**[`modules`](#modules)**|`{Boolean}`|`false`|Enable/Disable CSS Modules|
+|**[`localIdentName`](#localidentname)**|`{String}`|`[hash:base64]`|Configure the generated ident|
+|**[`sourceMap`](#sourcemap)**|`{Boolean}`|`false`|Enable/Disable Sourcemaps|
+|**[`camelCase`](#camelcase)**|`{Boolean\|String}`|`false`|Export Classnames in CamelCase|
+|**[`importLoaders`](#importloaders)**|`{Number}`|`0`|Number of loaders applied before CSS loader|
+
+### `url`
+
+To disable `url()` resolving by `css-loader` set the option to `false`.
+
+To be compatible with existing css files (if not in CSS Module mode).
+
+```
+url(image.png) => require('./image.png')
+url(~module/image.png) => require('module/image.png')
+```
+
+### `import`
+
+To disable `@import` resolving by `css-loader` set the option to `false`
+
+```css
+@import url('https://fonts.googleapis.com/css?family=Roboto');
+```
+
+> _⚠️ Use with caution, since this disables resolving for **all** `@import`s, including css modules `composes: xxx from 'path/to/file.css'` feature._
+
+### [`modules`](https://github.com/css-modules/css-modules)
+
+The query parameter `modules` enables the **CSS Modules** spec.
+
+This enables local scoped CSS by default. (You can switch it off with `:global(...)` or `:global` for selectors and/or rules.).
+
+#### `Scope`
+
+By default CSS exports all classnames into a global selector scope. Styles can be locally scoped to avoid globally scoping styles.
+
+The syntax `:local(.className)` can be used to declare `className` in the local scope. The local identifiers are exported by the module.
+
+With `:local` (without brackets) local mode can be switched on for this selector. `:global(.className)` can be used to declare an explicit global selector. With `:global` (without brackets) global mode can be switched on for this selector.
+
+The loader replaces local selectors with unique identifiers. The chosen unique identifiers are exported by the module.
+
+```css
+:local(.className) { background: red; }
+:local .className { color: green; }
+:local(.className .subClass) { color: green; }
+:local .className .subClass :global(.global-class-name) { color: blue; }
+```
+
+```css
+._23_aKvs-b8bW2Vg3fwHozO { background: red; }
+._23_aKvs-b8bW2Vg3fwHozO { color: green; }
+._23_aKvs-b8bW2Vg3fwHozO ._13LGdX8RMStbBE9w-t0gZ1 { color: green; }
+._23_aKvs-b8bW2Vg3fwHozO ._13LGdX8RMStbBE9w-t0gZ1 .global-class-name { color: blue; }
+```
+
+> ℹ️ Identifiers are exported
+
+```js
+exports.locals = {
+  className: '_23_aKvs-b8bW2Vg3fwHozO',
+  subClass: '_13LGdX8RMStbBE9w-t0gZ1'
+}
+```
+
+CamelCase is recommended for local selectors. They are easier to use within the imported JS module.
+
+`url()` URLs in block scoped (`:local .abc`) rules behave like requests in modules.
+
+```
+file.png => ./file.png
+~module/file.png => module/file.png
+```
+
+You can use `:local(#someId)`, but this is not recommended. Use classes instead of ids.
+
+#### `Composing`
+
+When declaring a local classname you can compose a local class from another local classname.
+
+```css
+:local(.className) {
+  background: red;
+  color: yellow;
+}
+
+:local(.subClass) {
+  composes: className;
+  background: blue;
+}
+```
+
+This doesn't result in any change to the CSS itself but exports multiple classnames.
+
+```js
+exports.locals = {
+  className: '_23_aKvs-b8bW2Vg3fwHozO',
+  subClass: '_13LGdX8RMStbBE9w-t0gZ1 _23_aKvs-b8bW2Vg3fwHozO'
+}
+```
+
+``` css
+._23_aKvs-b8bW2Vg3fwHozO {
+  background: red;
+  color: yellow;
+}
+
+._13LGdX8RMStbBE9w-t0gZ1 {
+  background: blue;
+}
+```
+
+#### `Importing`
+
+To import a local classname from another module.
+
+```css
+:local(.continueButton) {
+  composes: button from 'library/button.css';
+  background: red;
+}
+```
+
+```css
+:local(.nameEdit) {
+  composes: edit highlight from './edit.css';
+  background: red;
+}
+```
+
+To import from multiple modules use multiple `composes:` rules.
+
+```css
+:local(.className) {
+  composes: edit hightlight from './edit.css';
+  composes: button from 'module/button.css';
+  composes: classFromThisModule;
+  background: red;
+}
+```
+
+### `localIdentName`
+
+You can configure the generated ident with the `localIdentName` query parameter. See [loader-utils's documentation](https://github.com/webpack/loader-utils#interpolatename) for more information on options.
+
+ **webpack.config.js**
+```js
+{
+  test: /\.css$/,
+  use: [
+    {
+      loader: 'css-loader',
+      options: {
+        modules: true,
+        localIdentName: '[path][name]__[local]--[hash:base64:5]'
+      }
+    }
+  ]
+}
+```
+
+You can also specify the absolute path to your custom `getLocalIdent` function to generate classname based on a different schema. This requires `webpack >= 2.2.1` (it supports functions in the `options` object).
+
+**webpack.config.js**
+```js
+{
+  loader: 'css-loader',
+  options: {
+    modules: true,
+    localIdentName: '[path][name]__[local]--[hash:base64:5]',
+    getLocalIdent: (context, localIdentName, localName, options) => {
+      return 'whatever_random_class_name'
+    }
+  }
+}
+```
+
+> ℹ️ For prerendering with extract-text-webpack-plugin you should use `css-loader/locals` instead of `style-loader!css-loader` **in the prerendering bundle**. It doesn't embed CSS but only exports the identifier mappings.
+
+### `sourceMap`
+
+To include source maps set the `sourceMap` option.
+
+I.e. the extract-text-webpack-plugin can handle them.
+
+They are not enabled by default because they expose a runtime overhead and increase in bundle size (JS source maps do not). In addition to that relative paths are buggy and you need to use an absolute public path which includes the server URL.
+
+**webpack.config.js**
+```js
+{
+  loader: 'css-loader',
+  options: {
+    sourceMap: true
+  }
+}
+```
+
+### `camelCase`
+
+By default, the exported JSON keys mirror the class names. If you want to camelize class names (useful in JS), pass the query parameter `camelCase` to css-loader.
+
+|Name|Type|Description|
+|:--:|:--:|:----------|
+|**`true`**|`{Boolean}`|Class names will be camelized|
+|**`'dashes'`**|`{String}`|Only dashes in class names will be camelized|
+|**`'only'`** |`{String}`|Introduced in `0.27.1`. Class names will be camelized, the original class name will be removed from the locals|
+|**`'dashesOnly'`**|`{String}`|Introduced in `0.27.1`. Dashes in class names will be camelized, the original class name will be removed from the locals|
+
+**file.css**
+```css
+.class-name {}
+```
+
+**file.js**
+```js
+import { className } from 'file.css';
+```
+
+**webpack.config.js**
+```js
+{
+  loader: 'css-loader',
+  options: {
+    camelCase: true
+  }
+}
+```
+
+### `importLoaders`
+
+The query parameter `importLoaders` allows you to configure how many loaders before `css-loader` should be applied to `@import`ed resources.
+
+**webpack.config.js**
+```js
+{
+  test: /\.css$/,
+  use: [
+    'style-loader',
+    {
+      loader: 'css-loader',
+      options: {
+        importLoaders: 2 // 0 => no loaders (default); 1 => postcss-loader; 2 => postcss-loader, sass-loader
+      }
+    },
+    'postcss-loader',
+    'sass-loader'
+  ]
+}
+```
+
+This may change in the future when the module system (i. e. webpack) supports loader matching by origin.
+
+<h2 align="center">Examples</h2>
+
+### Assets
+
+The following `webpack.config.js` can load CSS files, embed small PNG/JPG/GIF/SVG images as well as fonts as [Data URLs](https://tools.ietf.org/html/rfc2397) and copy larger files to the output directory.
+
+**webpack.config.js**
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        use: [ 'style-loader', 'css-loader' ]
+      },
+      {
+        test: /\.(png|jpg|gif|svg|eot|ttf|woff|woff2)$/,
+        loader: 'url-loader',
+        options: {
+          limit: 10000
+        }
+      }
+    ]
+  }
+}
+```
+
+### Extract
+
+For production builds it's recommended to extract the CSS from your bundle being able to use parallel loading of CSS/JS resources later on.
+This can be achieved by using the [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin) to extract the CSS when running in production mode.
+
+<h2 align="center">Maintainers</h2>
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/bebraw.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/bebraw">Juho Vepsäläinen</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/d3viant0ne.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/d3viant0ne">Joshua Wiens</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/SpaceK33z.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/SpaceK33z">Kees Kluskens</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/TheLarkInn.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/TheLarkInn">Sean Larkin</a>
+      </td>
+    </tr>
+    <tr>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/michael-ciniawsky.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/michael-ciniawsky">Michael Ciniawsky</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/evilebottnawi.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/evilebottnawi">Evilebot Tnawi</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://github.com/joscha.png?v=3&s=150">
+        </br>
+        <a href="https://github.com/joscha">Joscha Feth</a>
+      </td>
+    </tr>
+  <tbody>
+</table>
+
+
+[npm]: https://img.shields.io/npm/v/css-loader.svg
+[npm-url]: https://npmjs.com/package/css-loader
+
+[node]: https://img.shields.io/node/v/css-loader.svg
+[node-url]: https://nodejs.org
+
+[deps]: https://david-dm.org/webpack-contrib/css-loader.svg
+[deps-url]: https://david-dm.org/webpack-contrib/css-loader
+
+[tests]: http://img.shields.io/travis/webpack-contrib/css-loader.svg
+[tests-url]: https://travis-ci.org/webpack-contrib/css-loader
+
+[cover]: https://codecov.io/gh/webpack-contrib/css-loader/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/css-loader
+
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack

node_modules/@vue/cli-service/node_modules/css-loader/index.js

@@ -0,0 +1,5 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = require("./lib/loader");

node_modules/@vue/cli-service/node_modules/css-loader/lib/compile-exports.js

@@ -0,0 +1,51 @@
+var camelCase = require("lodash/camelCase");
+
+function dashesCamelCase(str) {
+  return str.replace(/-+(\w)/g, function(match, firstLetter) {
+    return firstLetter.toUpperCase();
+  });
+}
+
+module.exports = function compileExports(result, importItemMatcher, camelCaseKeys) {
+  if (!Object.keys(result.exports).length) {
+    return "";
+  }
+
+  var exportJs = Object.keys(result.exports).reduce(function(res, key) {
+    var valueAsString = JSON.stringify(result.exports[key]);
+    valueAsString = valueAsString.replace(result.importItemRegExpG, importItemMatcher);
+    function addEntry(k) {
+      res.push("\t" + JSON.stringify(k) + ": " + valueAsString);
+    }
+
+    var targetKey;
+    switch(camelCaseKeys) {
+      case true:
+        addEntry(key);
+        targetKey = camelCase(key);
+        if (targetKey !== key) {
+          addEntry(targetKey);
+        }
+        break;
+      case 'dashes':
+        addEntry(key);
+        targetKey = dashesCamelCase(key);
+        if (targetKey !== key) {
+          addEntry(targetKey);
+        }
+        break;
+      case 'only':
+        addEntry(camelCase(key));
+        break;
+      case 'dashesOnly':
+        addEntry(dashesCamelCase(key));
+        break;
+      default:
+        addEntry(key);
+        break;
+    }
+    return res;
+  }, []).join(",\n");
+
+  return "{\n" + exportJs + "\n}";
+};

node_modules/@vue/cli-service/node_modules/css-loader/lib/css-base.js

@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+// css base code, injected by the css-loader
+module.exports = function(useSourceMap) {
+	var list = [];
+
+	// return the list of modules as css string
+	list.toString = function toString() {
+		return this.map(function (item) {
+			var content = cssWithMappingToString(item, useSourceMap);
+			if(item[2]) {
+				return "@media " + item[2] + "{" + content + "}";
+			} else {
+				return content;
+			}
+		}).join("");
+	};
+
+	// import a list of modules into the list
+	list.i = function(modules, mediaQuery) {
+		if(typeof modules === "string")
+			modules = [[null, modules, ""]];
+		var alreadyImportedModules = {};
+		for(var i = 0; i < this.length; i++) {
+			var id = this[i][0];
+			if(typeof id === "number")
+				alreadyImportedModules[id] = true;
+		}
+		for(i = 0; i < modules.length; i++) {
+			var item = modules[i];
+			// skip already imported module
+			// this implementation is not 100% perfect for weird media query combinations
+			//  when a module is imported multiple times with different media queries.
+			//  I hope this will never occur (Hey this way we have smaller bundles)
+			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
+				if(mediaQuery && !item[2]) {
+					item[2] = mediaQuery;
+				} else if(mediaQuery) {
+					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
+				}
+				list.push(item);
+			}
+		}
+	};
+	return list;
+};
+
+function cssWithMappingToString(item, useSourceMap) {
+	var content = item[1] || '';
+	var cssMapping = item[3];
+	if (!cssMapping) {
+		return content;
+	}
+
+	if (useSourceMap && typeof btoa === 'function') {
+		var sourceMapping = toComment(cssMapping);
+		var sourceURLs = cssMapping.sources.map(function (source) {
+			return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
+		});
+
+		return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
+	}
+
+	return [content].join('\n');
+}
+
+// Adapted from convert-source-map (MIT)
+function toComment(sourceMap) {
+	// eslint-disable-next-line no-undef
+	var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
+	var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
+
+	return '/*# ' + data + ' */';
+}

node_modules/@vue/cli-service/node_modules/css-loader/lib/getImportPrefix.js

@@ -0,0 +1,14 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = function getImportPrefix(loaderContext, query) {
+	if(query.importLoaders === false)
+		return "";
+	var importLoaders = parseInt(query.importLoaders, 10) || 0;
+	var loadersRequest = loaderContext.loaders.slice(
+		loaderContext.loaderIndex,
+		loaderContext.loaderIndex + 1 + importLoaders
+	).map(function(x) { return x.request; }).join("!");
+	return "-!" + loadersRequest + "!";
+};

node_modules/@vue/cli-service/node_modules/css-loader/lib/getLocalIdent.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var path = require("path");
+
+module.exports = function getLocalIdent(loaderContext, localIdentName, localName, options) {
+	if(!options.context) {
+		if (loaderContext.rootContext) {
+			options.context = loaderContext.rootContext;
+		} else if (loaderContext.options && typeof loaderContext.options.context === "string") {
+			options.context = loaderContext.options.context;
+		} else {
+			options.context = loaderContext.context;
+		}
+	}
+	var request = path.relative(options.context, loaderContext.resourcePath);
+	options.content = options.hashPrefix + request + "+" + localName;
+	localIdentName = localIdentName.replace(/\[local\]/gi, localName);
+	var hash = loaderUtils.interpolateName(loaderContext, localIdentName, options);
+	return hash.replace(new RegExp("[^a-zA-Z0-9\\-_\u00A0-\uFFFF]", "g"), "-").replace(/^((-?[0-9])|--)/, "_$1");
+};

node_modules/@vue/cli-service/node_modules/css-loader/lib/loader.js

@@ -0,0 +1,144 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var processCss = require("./processCss");
+var getImportPrefix = require("./getImportPrefix");
+var compileExports = require("./compile-exports");
+
+
+module.exports = function(content, map) {
+	var callback = this.async();
+	var query = loaderUtils.getOptions(this) || {};
+	var moduleMode = query.modules;
+	var camelCaseKeys = query.camelCase;
+	var sourceMap = query.sourceMap || false;
+
+	if(sourceMap) {
+		if (map) {
+			if (typeof map === "string") {
+				map = JSON.stringify(map);
+			}
+
+			if (map.sources) {
+				map.sources = map.sources.map(function (source) {
+					return source.replace(/\\/g, '/');
+				});
+				map.sourceRoot = '';
+			}
+		}
+	} else {
+		// Some loaders (example `"postcss-loader": "1.x.x"`) always generates source map, we should remove it
+		map = null;
+	}
+
+	processCss(content, map, {
+		mode: moduleMode ? "local" : "global",
+		from: loaderUtils.getRemainingRequest(this).split("!").pop(),
+		to: loaderUtils.getCurrentRequest(this).split("!").pop(),
+		query: query,
+		loaderContext: this,
+		sourceMap: sourceMap
+	}, function(err, result) {
+		if(err) return callback(err);
+
+		var cssAsString = JSON.stringify(result.source);
+
+		// for importing CSS
+		var importUrlPrefix = getImportPrefix(this, query);
+
+		var alreadyImported = {};
+		var importJs = result.importItems.map(function(imp) {
+			// fixes #781 when importing `url(filename.css )`
+			imp.url = imp.url.trim();
+			return imp;
+		}).filter(function(imp) {
+			if(!imp.mediaQuery) {
+				if(alreadyImported[imp.url])
+					return false;
+				alreadyImported[imp.url] = true;
+			}
+			return true;
+		}).map(function(imp) {
+			if(!loaderUtils.isUrlRequest(imp.url)) {
+				return "exports.push([module.id, " +
+					JSON.stringify("@import url(" + imp.url + ");") + ", " +
+					JSON.stringify(imp.mediaQuery) + "]);";
+			} else {
+				var importUrl = importUrlPrefix + imp.url;
+				return "exports.i(require(" + loaderUtils.stringifyRequest(this, importUrl) + "), " + JSON.stringify(imp.mediaQuery) + ");";
+			}
+		}, this).join("\n");
+
+		function importItemMatcher(item) {
+			var match = result.importItemRegExp.exec(item);
+			var idx = +match[1];
+			var importItem = result.importItems[idx];
+			var importUrl = importUrlPrefix + importItem.url;
+			return "\" + require(" + loaderUtils.stringifyRequest(this, importUrl) + ").locals" +
+				"[" + JSON.stringify(importItem.export) + "] + \"";
+		}
+
+		cssAsString = cssAsString.replace(result.importItemRegExpG, importItemMatcher.bind(this));
+
+		// helper for ensuring valid CSS strings from requires
+		var urlEscapeHelper = "";
+
+		if(query.url !== false && result.urlItems.length > 0) {
+			urlEscapeHelper = "var escape = require(" + loaderUtils.stringifyRequest(this, require.resolve("./url/escape.js")) + ");\n";
+
+			cssAsString = cssAsString.replace(result.urlItemRegExpG, function(item) {
+				var match = result.urlItemRegExp.exec(item);
+				var idx = +match[1];
+				var urlItem = result.urlItems[idx];
+				var url = urlItem.url;
+				idx = url.indexOf("?#");
+				if(idx < 0) idx = url.indexOf("#");
+				var urlRequest;
+				if(idx > 0) { // idx === 0 is catched by isUrlRequest
+					// in cases like url('webfont.eot?#iefix')
+					urlRequest = url.substr(0, idx);
+					return "\" + escape(require(" + loaderUtils.stringifyRequest(this, urlRequest) + ")) + \"" +
+							url.substr(idx);
+				}
+				urlRequest = url;
+				return "\" + escape(require(" + loaderUtils.stringifyRequest(this, urlRequest) + ")) + \"";
+			}.bind(this));
+		}
+
+		var exportJs = compileExports(result, importItemMatcher.bind(this), camelCaseKeys);
+		if (exportJs) {
+			exportJs = "exports.locals = " + exportJs + ";";
+		}
+
+		var moduleJs;
+		if(sourceMap && result.map) {
+			// add a SourceMap
+			map = result.map;
+			if(map.sources) {
+				map.sources = map.sources.map(function(source) {
+					return source.split("!").pop().replace(/\\/g, '/');
+				}, this);
+				map.sourceRoot = "";
+			}
+			map.file = map.file.split("!").pop().replace(/\\/g, '/');
+			map = JSON.stringify(map);
+			moduleJs = "exports.push([module.id, " + cssAsString + ", \"\", " + map + "]);";
+		} else {
+			moduleJs = "exports.push([module.id, " + cssAsString + ", \"\"]);";
+		}
+
+		// embed runtime
+		callback(null, urlEscapeHelper +
+			"exports = module.exports = require(" +
+			loaderUtils.stringifyRequest(this, require.resolve("./css-base.js")) +
+			")(" + sourceMap + ");\n" +
+			"// imports\n" +
+			importJs + "\n\n" +
+			"// module\n" +
+			moduleJs + "\n\n" +
+			"// exports\n" +
+			exportJs);
+	}.bind(this));
+};

node_modules/@vue/cli-service/node_modules/css-loader/lib/localsLoader.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderUtils = require("loader-utils");
+var processCss = require("./processCss");
+var getImportPrefix = require("./getImportPrefix");
+var compileExports = require("./compile-exports");
+
+
+module.exports = function(content) {
+	var callback = this.async();
+	var query = loaderUtils.getOptions(this) || {};
+	var moduleMode = query.modules;
+	var camelCaseKeys = query.camelCase;
+
+	processCss(content, null, {
+		mode: moduleMode ? "local" : "global",
+		query: query,
+		loaderContext: this,
+	}, function(err, result) {
+		if(err) return callback(err);
+
+		// for importing CSS
+		var importUrlPrefix = getImportPrefix(this, query);
+
+		function importItemMatcher(item) {
+			var match = result.importItemRegExp.exec(item);
+			var idx = +match[1];
+			var importItem = result.importItems[idx];
+			var importUrl = importUrlPrefix + importItem.url;
+			return "\" + require(" + loaderUtils.stringifyRequest(this, importUrl) + ")" +
+				"[" + JSON.stringify(importItem.export) + "] + \"";
+		}
+
+		var exportJs = compileExports(result, importItemMatcher.bind(this), camelCaseKeys);
+		if (exportJs) {
+			exportJs = "module.exports = " + exportJs + ";";
+		}
+
+
+		callback(null, exportJs);
+	}.bind(this));
+};

node_modules/@vue/cli-service/node_modules/css-loader/lib/processCss.js

@@ -0,0 +1,244 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var formatCodeFrame = require("babel-code-frame");
+var Tokenizer = require("css-selector-tokenizer");
+var postcss = require("postcss");
+var loaderUtils = require("loader-utils");
+var getLocalIdent = require("./getLocalIdent");
+
+var icssUtils = require('icss-utils');
+var localByDefault = require("postcss-modules-local-by-default");
+var extractImports = require("postcss-modules-extract-imports");
+var modulesScope = require("postcss-modules-scope");
+var modulesValues = require("postcss-modules-values");
+var valueParser = require('postcss-value-parser');
+
+var parserPlugin = postcss.plugin("css-loader-parser", function(options) {
+	return function(css) {
+		var imports = {};
+		var exports = {};
+		var importItems = [];
+		var urlItems = [];
+
+		function replaceImportsInString(str) {
+			if(options.import) {
+				var tokens = valueParser(str);
+				tokens.walk(function (node) {
+					if (node.type !== 'word') {
+						return;
+					}
+					var token = node.value;
+					var importIndex = imports["$" + token];
+					if(typeof importIndex === "number") {
+						node.value = "___CSS_LOADER_IMPORT___" + importIndex + "___";
+					}
+				})
+				return tokens.toString();
+			}
+			return str;
+		}
+
+		if(options.import) {
+			css.walkAtRules(/^import$/i, function(rule) {
+				var values = Tokenizer.parseValues(rule.params);
+				var url = values.nodes[0].nodes[0];
+				if(url && url.type === "url") {
+					url = url.url;
+				} else if(url && url.type === "string") {
+					url = url.value;
+				} else throw rule.error("Unexpected format " + rule.params);
+				if (!url.replace(/\s/g, '').length) {
+					return;
+				}
+				values.nodes[0].nodes.shift();
+				var mediaQuery = Tokenizer.stringifyValues(values);
+
+				if(loaderUtils.isUrlRequest(url)) {
+					url = loaderUtils.urlToRequest(url);
+				}
+
+				importItems.push({
+					url: url,
+					mediaQuery: mediaQuery
+				});
+				rule.remove();
+			});
+		}
+
+		var icss = icssUtils.extractICSS(css);
+		exports = icss.icssExports;
+		Object.keys(icss.icssImports).forEach(function(key) {
+			var url = loaderUtils.parseString(key);
+			Object.keys(icss.icssImports[key]).forEach(function(prop) {
+				imports["$" + prop] = importItems.length;
+				importItems.push({
+					url: url,
+					export: icss.icssImports[key][prop]
+				});
+			})
+		});
+
+		Object.keys(exports).forEach(function(exportName) {
+			exports[exportName] = replaceImportsInString(exports[exportName]);
+		});
+
+		function processNode(item) {
+			switch (item.type) {
+				case "value":
+					item.nodes.forEach(processNode);
+					break;
+				case "nested-item":
+					item.nodes.forEach(processNode);
+					break;
+				case "item":
+					var importIndex = imports["$" + item.name];
+					if (typeof importIndex === "number") {
+						item.name = "___CSS_LOADER_IMPORT___" + importIndex + "___";
+					}
+					break;
+				case "url":
+					if (options.url && item.url.replace(/\s/g, '').length && !/^#/.test(item.url) && loaderUtils.isUrlRequest(item.url)) {
+						// Strip quotes, they will be re-added if the module needs them
+						item.stringType = "";
+						delete item.innerSpacingBefore;
+						delete item.innerSpacingAfter;
+						var url = item.url;
+						item.url = "___CSS_LOADER_URL___" + urlItems.length + "___";
+						urlItems.push({
+							url: url
+						});
+					}
+					break;
+			}
+		}
+
+		css.walkDecls(function(decl) {
+			var values = Tokenizer.parseValues(decl.value);
+			values.nodes.forEach(function(value) {
+				value.nodes.forEach(processNode);
+			});
+			decl.value = Tokenizer.stringifyValues(values);
+		});
+		css.walkAtRules(function(atrule) {
+			if(typeof atrule.params === "string") {
+				atrule.params = replaceImportsInString(atrule.params);
+			}
+		});
+
+		options.importItems = importItems;
+		options.urlItems = urlItems;
+		options.exports = exports;
+	};
+});
+
+module.exports = function processCss(inputSource, inputMap, options, callback) {
+	var query = options.query;
+	var context = query.context;
+	var localIdentName = query.localIdentName || "[hash:base64]";
+	var localIdentRegExp = query.localIdentRegExp;
+
+	var customGetLocalIdent = query.getLocalIdent || getLocalIdent;
+
+	var parserOptions = {
+		mode: options.mode,
+		url: query.url !== false,
+		import: query.import !== false,
+		resolve: options.resolve
+	};
+
+	var pipeline = postcss([
+		modulesValues,
+		localByDefault({
+			mode: options.mode,
+			rewriteUrl: function(global, url) {
+				if(parserOptions.url){
+                    url = url.trim();
+
+					if(!url.replace(/\s/g, '').length || !loaderUtils.isUrlRequest(url)) {
+						return url;
+					}
+					if(global) {
+						return loaderUtils.urlToRequest(url);
+					}
+				}
+				return url;
+			}
+		}),
+		extractImports(),
+		modulesScope({
+			generateScopedName: function generateScopedName (exportName) {
+				return customGetLocalIdent(options.loaderContext, localIdentName, exportName, {
+					regExp: localIdentRegExp,
+					hashPrefix: query.hashPrefix || "",
+					context: context
+				});
+			}
+		}),
+		parserPlugin(parserOptions)
+	]);
+
+	pipeline.process(inputSource, {
+		// we need a prefix to avoid path rewriting of PostCSS
+		from: "/css-loader!" + options.from,
+		to: options.to,
+		map: options.sourceMap ? {
+			prev: inputMap,
+			sourcesContent: true,
+			inline: false,
+			annotation: false
+		} : null
+	}).then(function(result) {
+		callback(null, {
+			source: result.css,
+			map: result.map && result.map.toJSON(),
+			exports: parserOptions.exports,
+			importItems: parserOptions.importItems,
+			importItemRegExpG: /___CSS_LOADER_IMPORT___([0-9]+)___/g,
+			importItemRegExp: /___CSS_LOADER_IMPORT___([0-9]+)___/,
+			urlItems: parserOptions.urlItems,
+			urlItemRegExpG: /___CSS_LOADER_URL___([0-9]+)___/g,
+			urlItemRegExp: /___CSS_LOADER_URL___([0-9]+)___/
+		});
+	}).catch(function(err) {
+		if (err.name === 'CssSyntaxError') {
+			var wrappedError = new CSSLoaderError(
+				'Syntax Error',
+				err.reason,
+				err.line != null && err.column != null
+					? {line: err.line, column: err.column}
+					: null,
+				err.input.source
+			);
+			callback(wrappedError);
+		} else {
+			callback(err);
+		}
+	});
+};
+
+function formatMessage(message, loc, source) {
+	var formatted = message;
+	if (loc) {
+		formatted = formatted
+			+ ' (' + loc.line + ':' + loc.column + ')';
+	}
+	if (loc && source) {
+		formatted = formatted
+			+ '\n\n' + formatCodeFrame(source, loc.line, loc.column) + '\n';
+	}
+	return formatted;
+}
+
+function CSSLoaderError(name, message, loc, source, error) {
+	Error.call(this);
+	Error.captureStackTrace(this, CSSLoaderError);
+	this.name = name;
+	this.error = error;
+	this.message = formatMessage(message, loc, source);
+	this.hideStack = true;
+}
+
+CSSLoaderError.prototype = Object.create(Error.prototype);
+CSSLoaderError.prototype.constructor = CSSLoaderError;

node_modules/@vue/cli-service/node_modules/css-loader/lib/url/escape.js

@@ -0,0 +1,16 @@
+module.exports = function escape(url) {
+    if (typeof url !== 'string') {
+        return url
+    }
+    // If url is already wrapped in quotes, remove them
+    if (/^['"].*['"]$/.test(url)) {
+        url = url.slice(1, -1);
+    }
+    // Should url be wrapped?
+    // See https://drafts.csswg.org/css-values-3/#urls
+    if (/["'() \t\n]/.test(url)) {
+        return '"' + url.replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"'
+    }
+
+    return url
+}

node_modules/@vue/cli-service/node_modules/css-loader/locals.js

@@ -0,0 +1,5 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = require("./lib/localsLoader");

node_modules/@vue/cli-service/node_modules/css-loader/package.json

@@ -0,0 +1,84 @@
+{
+  "_from": "css-loader@^1.0.1",
+  "_id": "css-loader@1.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-+ZHAZm/yqvJ2kDtPne3uX0C+Vr3Zn5jFn2N4HywtS5ujwvsVkyg0VArEXpl3BgczDA8anieki1FIzhchX4yrDw==",
+  "_location": "/@vue/cli-service/css-loader",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "css-loader@^1.0.1",
+    "name": "css-loader",
+    "escapedName": "css-loader",
+    "rawSpec": "^1.0.1",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.1"
+  },
+  "_requiredBy": [
+    "/@vue/cli-service"
+  ],
+  "_resolved": "https://registry.npmjs.org/css-loader/-/css-loader-1.0.1.tgz",
+  "_shasum": "6885bb5233b35ec47b006057da01cc640b6b79fe",
+  "_spec": "css-loader@^1.0.1",
+  "_where": "D:\\Atom\\Git\\Laravel_CSSd\\node_modules\\@vue\\cli-service",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack-contrib/css-loader/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "babel-code-frame": "^6.26.0",
+    "css-selector-tokenizer": "^0.7.0",
+    "icss-utils": "^2.1.0",
+    "loader-utils": "^1.0.2",
+    "lodash": "^4.17.11",
+    "postcss": "^6.0.23",
+    "postcss-modules-extract-imports": "^1.2.0",
+    "postcss-modules-local-by-default": "^1.2.0",
+    "postcss-modules-scope": "^1.1.0",
+    "postcss-modules-values": "^1.3.0",
+    "postcss-value-parser": "^3.3.0",
+    "source-list-map": "^2.0.0"
+  },
+  "deprecated": false,
+  "description": "css loader module for webpack",
+  "devDependencies": {
+    "codecov": "^1.0.1",
+    "eslint": "3.14.0",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.2.0",
+    "should": "^11.1.2",
+    "standard-version": "^4.0.0"
+  },
+  "engines": {
+    "node": ">= 6.9.0 <7.0.0 || >= 8.9.0"
+  },
+  "files": [
+    "lib",
+    "index.js",
+    "locals.js"
+  ],
+  "homepage": "https://github.com/webpack-contrib/css-loader",
+  "license": "MIT",
+  "name": "css-loader",
+  "peerDependencies": {
+    "webpack": "^4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack-contrib/css-loader.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha",
+    "lint": "eslint lib test",
+    "release": "standard-version",
+    "test": "mocha",
+    "test:cover": "npm run cover -- --report lcovonly",
+    "travis:lint": "npm run lint",
+    "travis:test": "npm run cover"
+  },
+  "version": "1.0.1"
+}

node_modules/@vue/cli-service/node_modules/postcss/CHANGELOG.md

@@ -0,0 +1,552 @@
+# Change Log
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## 6.0.23
+* Fix parsing nested at-rules without semicolon, params, and spaces.
+
+## 6.0.22
+* Fix `Node#prev` and `Node#next` on missed parent.
+
+## 6.0.21
+* Rename Chinese docs to fix `yarnpkg.com` issue.
+
+## 6.0.20
+* Better error message on `null` as input CSS.
+
+## 6.0.19
+* Fix TypeScript definitions for source maps (by Oleh Kuchuk).
+* Fix `source` field in TypeScript definitions (by Sylvain Pollet-Villard).
+
+## 6.0.18
+* Use primitive object in TypeScript definitions (by Sylvain Pollet-Villard).
+
+## 6.0.17
+* Fix parsing comment in selector between word tokens (by Oleh Kuchuk).
+
+## 6.0.16
+* Fix warning text (by Michael Keller).
+
+## 6.0.15
+* Add warning about missed `from` option on `process().then()` call.
+* Add IE 10 support.
+
+## 6.0.14
+* Fix TypeScript definitions (by Jed Mao).
+
+## 6.0.13
+* Fix TypeScript definitions for case of multiple PostCSS versions
+  in `node_modules` (by Chris Eppstein).
+* Use `source-map` 0.6.
+
+## 6.0.12
+* Don’t copy `*` hack to declaration indent.
+
+## 6.0.11
+* Add upper case `!IMPORTANT` support.
+
+## 6.0.10
+* Reduce PostCSS size in webpack bundle.
+
+## 6.0.9
+* Improve error message for plugin with old PostCSS (by Igor Adamenko).
+
+## 6.0.8
+* Fix Node.js 4.2.2 support.
+
+## 6.0.7
+* Fix base64 decoding for old Node.js and browser.
+
+## 6.0.6
+* Fix `end` position in at-rule without semicolon (by Oleh Kuchuk).
+
+## 6.0.5
+* Move Babel config from `package.json` for `node_modules` compiling cases.
+
+## 6.0.4
+* Fix parsing `;;` after rules.
+* Use Chalk 2.0.
+
+## 6.0.3
+* Fix escape sequences parsing (by Oleh Kuchuk).
+* Added ability to force disable colors with an environment variable.
+* Improved color detection of some terminal apps.
+
+## 6.0.2
+* Keep `raws.before` on moving `Root` children to new `Root`.
+
+## 6.0.1
+* Fix parser extensibility to use it in Safe Parser.
+
+## 6.0 “Marquis Orias”
+* Remove node.js 0.12 support.
+* Remove deprecated method from PostCSS 4.
+* Insert methods remove child from previous parent, instead of closing.
+* Insert methods and cloning doesn’t clean `raws` anymore.
+* Methods `moveTo`, `moveAfter`, `moveBefore` were deprecated.
+* Options was changed in `Plugin#process(css, processOptions, pluginOptions)`.
+* Add stream parser to reduce memory usage (by Oleh Kuchuk).
+* Add `before()`/`after()` shortcuts for `node.parent.insertBefore(node, x)`.
+* Add `Rule#raws.ownSemicolon` for semicolon after templates for `@apply`.
+* Use `babel-preset-env` to compile npm package.
+* Remove `js-base64` from dependencies (by Roman Dvornov).
+* Fix error message on single `:` in CSS.
+* Move tests to Jest.
+* Clean up test (by Gabriel Kalani).
+
+## 5.2.18
+* Fix TypeScript definitions for case of multiple PostCSS versions
+  in `node_modules` (by Chris Eppstein).
+
+## 5.2.17
+* Add `postcss-sass` suggestion to syntax error on `.sass` input.
+
+## 5.2.16
+* Better error on wrong argument in node constructor.
+
+## 5.2.15
+* Fix TypeScript definitions (by bumbleblym).
+
+## 5.2.14
+* Fix browser bundle building in webpack (by janschoenherr).
+
+## 5.2.13
+* Do not add comment to important raws.
+* Fix JSDoc (by Dmitry Semigradsky).
+
+## 5.2.12
+* Fix typo in deprecation message (by Garet McKinley).
+
+## 5.2.11
+* Fix TypeScript definitions (by Jed Mao).
+
+## 5.2.10
+* Fix TypeScript definitions (by Jed Mao).
+
+## 5.2.9
+* Update TypeScript definitions (by Jed Mao).
+
+## 5.2.8
+* Fix error message (by Ben Briggs).
+
+## 5.2.7
+* Better error message on syntax object in plugins list.
+
+## 5.2.6
+* Fix `postcss.vendor` for values with spaces (by 刘祺).
+
+## 5.2.5
+* Better error message on unclosed string (by Ben Briggs).
+
+## 5.2.4
+* Improve terminal CSS syntax highlight (by Simon Lydell).
+
+## 5.2.3
+* Better color highlight in syntax error code frame.
+* Fix color highlight support in old systems.
+
+## 5.2.2
+* Update `Processor#version`.
+
+## 5.2.1
+* Fix source map path for CSS without `from` option (by Michele Locati).
+
+## 5.2 “Duke Vapula”
+* Add syntax highlight to code frame in syntax error (by Andrey Popp).
+* Use Babel code frame style and size in syntax error.
+* Add `[` and `]` tokens to parse `[attr=;] {}` correctly.
+* Add `ignoreErrors` options to tokenizer (by Andrey Popp).
+* Fix error position on tab indent (by Simon Lydell).
+
+## 5.1.2
+* Suggests SCSS/Less parsers on parse errors depends on file extension.
+
+## 5.1.1
+* Fix TypeScript definitions (by Efremov Alexey).
+
+## 5.1 “King and President Zagan”
+* Add URI in source map support (by Mark Finger).
+* Add `map.from` option (by Mark Finger).
+* Add `<no source>` mappings for nodes without source (by Bogdan Chadkin).
+* Add function value support to `map.prev` option (by Chris Montoro).
+* Add declaration value type check in shortcut creating (by 刘祺).
+* `Result#warn` now returns new created warning.
+* Don’t call plugin creator in `postcss.plugin` call.
+* Add source maps to PostCSS ES5 build.
+* Add JSDoc to PostCSS classes.
+* Clean npm package from unnecessary docs.
+
+## 5.0.21
+* Fix support with input source mao with `utf8` encoding name.
+
+## 5.0.20
+* Fix between raw value parsing (by David Clark).
+* Update TypeScript definitions (by Jed Mao).
+* Clean fake node.source after `append(string)`.
+
+## 5.0.19
+* Fix indent-based syntaxes support.
+
+## 5.0.18
+* Parse new lines according W3C CSS syntax specification.
+
+## 5.0.17
+* Fix options argument in `Node#warn` (by Ben Briggs).
+* Fix TypeScript definitions (by Jed Mao).
+
+## 5.0.16
+* Fix CSS syntax error position on unclosed quotes.
+
+## 5.0.15
+* Fix `Node#clone()` on `null` value somewhere in node.
+
+## 5.0.14
+* Allow to use PostCSS in webpack bundle without JSON loader.
+
+## 5.0.13
+* Fix `index` and `word` options in `Warning#toString` (by Bogdan Chadkin).
+* Fix input source content loading in errors.
+* Fix map options on using `LazyResult` as input CSS.
+* 100% test coverage.
+* Use Babel 6.
+
+## 5.0.12
+* Allow passing a previous map with no mappings (by Andreas Lind).
+
+## 5.0.11
+* Increase plugins performance by 1.5 times.
+
+## 5.0.10
+* Fix warning from nodes without source.
+
+## 5.0.9
+* Fix source map type detection (by @asan).
+
+## 5.0.8
+* Fixed a missed step in `5.0.7` that caused the module to be published as
+  ES6 code.
+
+## 5.0.7
+* PostCSS now requires that node 0.12 is installed via the engines property
+  in package.json (by Howard Zuo).
+
+## 5.0.6
+* Fix parsing nested at-rule without semicolon (by Matt Drake).
+* Trim `Declaration#value` (by Bogdan Chadkin).
+
+## 5.0.5
+* Fix multi-tokens property parsing (by Matt Drake).
+
+## 5.0.4
+* Fix start position in `Root#source`.
+* Fix source map annotation, when CSS uses `\r\n` (by Mohammad Younes).
+
+## 5.0.3
+* Fix `url()` parsing.
+* Fix using `selectors` in `Rule` constructor.
+* Add start source to `Root` node.
+
+## 5.0.2
+* Fix `remove(index)` to be compatible with 4.x plugin.
+
+## 5.0.1
+* Fix PostCSS 4.x plugins compatibility.
+* Fix type definition loading (by Jed Mao).
+
+## 5.0 “President Valac”
+* Remove `safe` option. Move Safe Parser to separate project.
+* `Node#toString` does not include `before` for root nodes.
+* Remove plugin returning `Root` API.
+* Remove Promise polyfill for node.js 0.10.
+* Deprecate `eachInside`, `eachDecl`, `eachRule`, `eachAtRule` and `eachComment`
+  in favor of `walk`, `walkDecls`, `walkRules`, `walkAtRules` and `walkComments`
+  (by Jed Mao).
+* Deprecate `Container#remove` and `Node#removeSelf`
+  in favor of `Container#removeChild` and `Node#remove` (by Ben Briggs).
+* Deprecate `Node#replace` in favor of `replaceWith` (by Ben Briggs).
+* Deprecate raw properties in favor of `Node#raws` object.
+* Deprecate `Node#style` in favor of `raw`.
+* Deprecate `CssSyntaxError#generated` in favor of `input`.
+* Deprecate `Node#cleanStyles` in favor of `cleanRaws`.
+* Deprecate `Root#prevMap` in favor of `Root.source.input.map`.
+* Add `syntax`, `parser` and `stringifier` options for Custom Syntaxes.
+* Add stringifier option to `Node#toString`.
+* Add `Result#content` alias for non-CSS syntaxes.
+* Add `plugin.process(css)` shortcut to every plugin function (by Ben Briggs).
+* Add multiple nodes support to insert methods (by Jonathan Neal).
+* Add `Node#warn` shortcut (by Ben Briggs).
+* Add `word` and `index` options to errors and warnings (by David Clark).
+* Add `line`, `column` properties to `Warning`.
+* Use `supports-color` library to detect color support in error output.
+* Add type definitions for TypeScript plugin developers (by Jed Mao).
+* `Rule#selectors` setter detects separators.
+* Add `postcss.stringify` method.
+* Throw descriptive errors for incorrectly formatted plugins.
+* Add docs to npm release.
+* Fix `url()` parsing.
+* Fix Windows support (by Jed Mao).
+
+## 4.1.16
+* Fix errors without stack trace.
+
+## 4.1.15
+* Allow asynchronous plugins to change processor plugins list (by Ben Briggs).
+
+## 4.1.14
+* Fix for plugins packs defined by `postcss.plugin`.
+
+## 4.1.13
+* Fix input inlined source maps with UTF-8 encoding.
+
+## 4.1.12
+* Update Promise polyfill.
+
+## 4.1.11
+* Fix error message on wrong plugin format.
+
+## 4.1.10
+* Fix Promise behavior on sync plugin errors.
+* Automatically fill `plugin` field in `CssSyntaxError`.
+* Fix warning message (by Ben Briggs).
+
+## 4.1.9
+* Speed up `node.clone()`.
+
+## 4.1.8
+* Accepts `Processor` instance in `postcss()` constructor too.
+
+## 4.1.7
+* Speed up `postcss.list` (by Bogdan Chadkin).
+
+## 4.1.6
+* Fix Promise behavior on parsing error.
+
+## 4.1.5
+* Parse at-words in declaration values.
+
+## 4.1.4
+* Fix Promise polyfill dependency (by Anton Yakushev and Matija Marohnić).
+
+## 4.1.3
+* Add Promise polyfill for node.js 0.10 and IE.
+
+## 4.1.2
+* List helpers can be accessed independently `var space = postcss.list.space`.
+
+## 4.1.1
+* Show deprecated message only once.
+
+## 4.1 “Marquis Andras”
+* Asynchronous plugin support.
+* Add warnings from plugins and `Result#messages`.
+* Add `postcss.plugin()` to create plugins with a standard API.
+* Insert nodes by CSS string.
+* Show version warning message on error from an outdated plugin.
+* Send `Result` instance to plugins as the second argument.
+* Add `CssSyntaxError#plugin`.
+* Add `CssSyntaxError#showSourceCode()`.
+* Add `postcss.list` and `postcss.vendor` aliases.
+* Add `Processor#version`.
+* Parse wrong closing bracket.
+* Parse `!important` statement with spaces and comments inside (by Ben Briggs).
+* Throw an error on declaration without `prop` or `value` (by Philip Peterson).
+* Fix source map mappings position.
+* Add indexed source map support.
+* Always set `error.generated`.
+* Clean all source map annotation comments.
+
+## 4.0.6
+* Remove `babel` from released package dependencies (by Andres Suarez).
+
+## 4.0.5
+* Fix error message on double colon in declaration.
+
+## 4.0.4
+* Fix indent detection in some rare cases.
+
+## 4.0.3
+* Faster API with 6to5 Loose mode.
+* Fix indexed source maps support.
+
+## 4.0.2
+* Do not copy IE hacks to code style.
+
+## 4.0.1
+* Add `source.input` to `Root` too.
+
+## 4.0 “Duke Flauros”
+* Rename `Container#childs` to `nodes`.
+* Rename `PostCSS#processors` to `plugins`.
+* Add `Node#replaceValues()` method.
+* Add `Node#moveTo()`, `moveBefore()` and `moveAfter()` methods.
+* Add `Node#cloneBefore()` and `cloneAfter()` shortcuts.
+* Add `Node#next()`, `prev()` and `root()` shortcuts.
+* Add `Node#replaceWith()` method.
+* Add `Node#error()` method.
+* Add `Container#removeAll()` method.
+* Add filter argument to `eachDecl()` and `eachAtRule()`.
+* Add `Node#source.input` and move `source.file` or `source.id` to `input`.
+* Change code indent, when node was moved.
+* Better fix code style on `Rule`, `AtRule` and `Comment` nodes changes.
+* Allow to create rules and at-rules by hash shortcut in append methods.
+* Add class name to CSS syntax error output.
+
+## 3.0.7
+* Fix IE filter parsing with multiple commands.
+* Safer way to consume PostCSS object as plugin (by Maxime Thirouin).
+
+## 3.0.6
+* Fix missing semicolon when comment comes after last declaration.
+* Fix Safe Mode declaration parsing on unclosed blocks.
+
+## 3.0.5
+* Fix parser to support difficult cases with backslash escape and brackets.
+* Add `CssSyntaxError#stack` (by Maxime Thirouin).
+
+## 3.0.4
+* Fix Safe Mode on unknown word before declaration.
+
+## 3.0.3
+* Increase tokenizer speed (by Roman Dvornov).
+
+## 3.0.2
+* Fix empty comment parsing.
+* Fix `Root#normalize` in some inserts.
+
+## 3.0.1
+* Fix Rhino JS runtime support.
+* Typo in deprecated warning (by Maxime Thirouin).
+
+## 3.0 “Marquis Andrealphus”
+* New parser, which become the fastest ever CSS parser written in JavaScript.
+* Parser can now parse declarations and rules in one parent (like in `@page`)
+  and nested declarations for plugins like `postcss-nested`.
+* Child nodes array is now in `childs` property, instead of `decls` and `rules`.
+* `map.inline` and `map.sourcesContent` options are now `true` by default.
+* Fix iterators (`each`, `insertAfter`) on children array changes.
+* Use previous source map to show origin source of CSS syntax error.
+* Use 6to5 ES6 compiler, instead of ES6 Transpiler.
+* Use code style for manually added rules from existing rules.
+* Use `from` option from previous source map `file` field.
+* Set `to` value to `from` if `to` option is missing.
+* Use better node source name when missing `from` option.
+* Show a syntax error when `;` is missed between declarations.
+* Allow to pass `PostCSS` instance or list of plugins to `use()` method.
+* Allow to pass `Result` instance to `process()` method.
+* Trim Unicode BOM on source maps parsing.
+* Parse at-rules without spaces like `@import"file"`.
+* Better previous `sourceMappingURL` annotation comment cleaning.
+* Do not remove previous `sourceMappingURL` comment on `map.annotation: false`.
+* Parse nameless at-rules in Safe Mode.
+* Fix source map generation for nodes without source.
+* Fix next child `before` if `Root` first child got removed.
+
+## 2.2.6
+* Fix map generation for nodes without source (by Josiah Savary).
+
+## 2.2.5
+* Fix source map with BOM marker support (by Mohammad Younes).
+* Fix source map paths (by Mohammad Younes).
+
+## 2.2.4
+* Fix `prepend()` on empty `Root`.
+
+## 2.2.3
+* Allow to use object shortcut in `use()` with functions like `autoprefixer`.
+
+## 2.2.2
+* Add shortcut to set processors in `use()` via object with `.postcss` property.
+
+## 2.2.1
+* Send `opts` from `Processor#process(css, opts)` to processors.
+
+## 2.2 “Marquis Cimeies”
+* Use GNU style syntax error messages.
+* Add `Node#replace` method.
+* Add `CssSyntaxError#reason` property.
+
+## 2.1.2
+* Fix UTF-8 support in inline source map.
+* Fix source map `sourcesContent` if there is no `from` and `to` options.
+
+## 2.1.1
+* Allow to miss `to` and `from` options for inline source maps.
+* Add `Node#source.id` if file name is unknown.
+* Better detect splitter between rules in CSS concatenation tools.
+* Automatically clone node in insert methods.
+
+## 2.1 “King Amdusias”
+* Change Traceur ES6 compiler to ES6 Transpiler.
+* Show broken CSS line in syntax error.
+
+## 2.0 “King Belial”
+* Project was rewritten from CoffeeScript to ES6.
+* Add Safe Mode to works with live input or with hacks from legacy code.
+* More safer parser to pass all hacks from Browserhacks.com.
+* Use real properties instead of magic getter/setter for raw properties.
+
+## 1.0 “Marquis Decarabia”
+* Save previous source map for each node to support CSS concatenation
+  with multiple previous maps.
+* Add `map.sourcesContent` option to add origin content to `sourcesContent`
+  inside map.
+* Allow to set different place of output map in annotation comment.
+* Allow to use arrays and `Root` in `Container#append` and same methods.
+* Add `Root#prevMap` with information about previous map.
+* Allow to use latest PostCSS from GitHub by npm.
+* `Result` now is lazy and it will generate output CSS only if you use `css`
+  or `map` property.
+* Use separated `map.prev` option to set previous map.
+* Rename `inlineMap` option to `map.inline`.
+* Rename `mapAnnotation` option to `map.annotation`.
+* `Result#map` now return `SourceMapGenerator` object, instead of string.
+* Run previous map autodetect only if input CSS contains annotation comment.
+* Add `map: 'inline'` shortcut for `map: { inline: true }` option.
+* `Node#source.file` now will contains absolute path.
+* Clean `Declaration#between` style on node clone.
+
+## 0.3.5
+* Allow to use `Root` or `Result` as first argument in `process()`.
+* Save parsed AST to `Result#root`.
+
+## 0.3.4
+* Better space symbol detect to read UTF-8 BOM correctly.
+
+## 0.3.3
+* Remove source map hacks by using new Mozilla’s `source-map` (by Simon Lydell).
+
+## 0.3.2
+* Add URI encoding support for inline source maps.
+
+## 0.3.1
+* Fix relative paths from previous source map.
+* Safer space split in `Rule#selectors` (by Simon Lydell).
+
+## 0.3 “Prince Seere”
+* Add `Comment` node for comments between declarations or rules.
+* Add source map annotation comment to output CSS.
+* Allow to inline source map to annotation comment by data:uri.
+* Fix source maps on Windows.
+* Fix source maps for subdirectory (by Dmitry Nikitenko and Simon Lydell).
+* Autodetect previous source map.
+* Add `first` and `last` shortcuts to container nodes.
+* Parse `!important` to separated property in `Declaration`.
+* Allow to break iteration by returning `false`.
+* Copy code style to new nodes.
+* Add `eachInside` method to recursively iterate all nodes.
+* Add `selectors` shortcut to get selectors array.
+* Add `toResult` method to `Rule` to simplify work with several input files.
+* Clean declaration’s `value`, rule’s `selector` and at-rule’s `params`
+  by storing spaces in `between` property.
+
+## 0.2 “Duke Dantalion”
+* Add source map support.
+* Add shortcuts to create nodes.
+* Method `process()` now returns object with `css` and `map` keys.
+* Origin CSS file option was renamed from `file` to `from`.
+* Rename `Node#remove()` method to `removeSelf()` to fix name conflict.
+* Node source was moved to `source` property with origin file
+  and node end position.
+* You can set own CSS generate function.
+
+## 0.1 “Count Andromalius”
+* Initial release.

node_modules/@vue/cli-service/node_modules/postcss/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing Guide to PostCSS
+
+If you want contribute to PostCSS, there are few things that you should
+be familiar with.
+
+
+## In Case You Have Question About Using PostCSS
+
+* **Ask for help in [the chat]**
+
+    If you stuck on something there is a big chance
+    that someone had similar problem before.
+
+[the chat]: https://gitter.im/postcss/postcss
+
+
+## Adding Your Plugin to the List
+
+If you created or found a plugin and want to add it to PostCSS plugins list
+follow this simple steps.
+
+PR should not change plugins defined in README it contains only favorite plugins
+and moderated by PostCSS author.
+
+Plugins submitted by community located in [`docs/plugins`].
+
+* **Keep plugins order**
+
+    Be sure that plugin not presented yet and find suitable position
+    in alphabetic order for it.
+    But plugins with `postcss-` prefix should come first.
+
+* **Check spelling**
+
+    Before submitting PR be sure that spelling check pass.
+    For that run command `npm test`.
+    If it fails with unknown word error, add it as word
+    to `.yaspellerrc` dictionary.
+
+* **Check PostCSS plugin guideline**
+
+    Provided plugin should match plugin [guidelines].
+
+- **Provide link to suggested plugin**
+
+    Make sure your pull request description contains link to plugin
+    you are willing to add.
+
+[`docs/plugins`]: https://github.com/postcss/postcss/blob/master/docs/plugins.md
+[guidelines]:     https://github.com/postcss/postcss/blob/master/docs/guidelines/plugin.md
+
+
+## TypeScript Declaration Improvements
+
+If you found a bug or want to add certain improvements to types declaration file
+
+* **Check current TypeScript styling**
+
+   Be sure that your changes match TypeScript styling rules defined in typings file.
+    * We use classes for existing JS classes like `Stringifier`.
+    * Namespaces used for separating functions related to same subject.
+    * Interfaces used for defining custom types.
+
+   Make sure you read through declaration file writing [best practices]
+   by TypeScript team.
+
+[best practices]: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html
+
+
+## Core Development
+
+If you want to add new feature or fix existed issue
+
+- **Become familiar with PostCSS architecture**
+
+    For gentle intro to PostCSS architecture look through our [guide].
+
+[guide]: https://github.com/postcss/postcss/blob/master/docs/architecture.md

node_modules/@vue/cli-service/node_modules/postcss/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+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.

node_modules/@vue/cli-service/node_modules/postcss/README-cn.md

@@ -0,0 +1,349 @@
+# PostCSS [![Gitter][chat-img]][chat]
+
+<img align="right" width="95" height="95"
+     alt="哲学家的石头 - PostCSS 的 logo"
+     src="http://postcss.github.io/postcss/logo.svg">
+
+[chat-img]: https://img.shields.io/badge/Gitter-Join_the_PostCSS_chat-brightgreen.svg
+[chat]:     https://gitter.im/postcss/postcss
+
+PostCSS 是一个允许使用 JS 插件转换样式的工具。
+这些插件可以检查（lint）你的 CSS，支持 CSS Variables 和 Mixins，
+编译尚未被浏览器广泛支持的先进的 CSS 语法，内联图片，以及其它很多优秀的功能。
+
+PostCSS 在工业界被广泛地应用，其中不乏很多有名的行业领导者，如：维基百科，Twitter，阿里巴巴，
+JetBrains。PostCSS 的 [Autoprefixer] 插件是最流行的 CSS 处理工具之一。
+
+PostCSS 接收一个 CSS 文件并提供了一个 API 来分析、修改它的规则（通过把 CSS 规则转换成一个[抽象语法树]的方式）。在这之后，这个 API 便可被许多[插件]利用来做有用的事情，比如寻错或自动添加 CSS vendor 前缀。
+
+**Twitter 账号:** [@postcss](https://twitter.com/postcss)<br>
+**支持 / 讨论:**   [Gitter](https://gitter.im/postcss/postcss)<br>
+
+如果需要 PostCSS 商业支持（如咨询，提升公司的前端文化，
+PostCSS 插件），请联系 [Evil Martians](https://evilmartians.com/?utm_source=postcss)
+邮箱 <surrender@evilmartians.com>。
+
+[抽象语法树]:     https://zh.wikipedia.org/wiki/%E6%8A%BD%E8%B1%A1%E8%AA%9E%E6%B3%95%E6%A8%B9
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+[插件]:          https://github.com/postcss/postcss/blob/master/README-cn.md#%E6%8F%92%E4%BB%B6
+
+<a href="https://evilmartians.com/?utm_source=postcss">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="由 Evil Martians 赞助" width="236" height="54">
+</a>
+
+## 插件
+
+截止到目前，PostCSS 有 200 多个插件。你可以在 [插件列表] 或 [搜索目录] 找到它们。
+下方的列表是我们最喜欢的插件 - 它们很好地演示了我们可以用 PostCSS 做些什么。
+
+如果你有任何新的想法，[开发 PostCSS 插件] 非常简单易上手。
+
+[搜索目录]: http://postcss.parts
+[插件列表]: https://github.com/postcss/postcss/blob/master/docs/plugins.md
+
+### 解决全局 CSS 的问题
+
+* [`postcss-use`] 允许你在 CSS 里明确地设置 PostCSS 插件，并且只在当前文件执行它们。
+* [`postcss-modules`] 和 [`react-css-modules`] 可以自动以组件为单位隔绝 CSS 选择器。
+* [`postcss-autoreset`] 是全局样式重置的又一个选择，它更适用于分离的组件。
+* [`postcss-initial`] 添加了 `all: initial` 的支持，重置了所有继承的样式。
+* [`cq-prolyfill`] 添加了容器查询的支持，允许添加响应于父元素宽度的样式.
+
+### 提前使用先进的 CSS 特性
+
+* [`autoprefixer`] 添加了 vendor 浏览器前缀，它使用 Can I Use 上面的数据。
+* [`postcss-preset-env`] 允许你使用未来的 CSS 特性。
+
+### 更佳的 CSS 可读性
+
+* [`precss`] 囊括了许多插件来支持类似 Sass 的特性，比如 CSS 变量，套嵌，mixins 等。
+* [`postcss-sorting`] 给规则的内容以及@规则排序。
+* [`postcss-utilities`] 囊括了最常用的简写方式和书写帮助。
+* [`short`] 添加并拓展了大量的缩写属性。
+
+### 图片和字体
+
+* [`postcss-assets`] 可以插入图片尺寸和内联文件。
+* [`postcss-sprites`] 能生成雪碧图。
+* [`font-magician`] 生成所有在 CSS 里需要的 `@font-face` 规则。
+* [`postcss-inline-svg`] 允许你内联 SVG 并定制它的样式。
+* [`postcss-write-svg`] 允许你在 CSS 里写简单的 SVG。
+
+### 提示器（Linters）
+
+* [`stylelint`] 是一个模块化的样式提示器。
+* [`stylefmt`] 是一个能根据 `stylelint` 规则自动优化 CSS 格式的工具。
+* [`doiuse`] 提示 CSS 的浏览器支持性，使用的数据来自于 Can I Use。
+* [`colorguard`] 帮助你保持一个始终如一的调色板。
+
+### 其它
+
+* [`postcss-rtl`] 在单个 CSS 文件里组合了两个方向（左到右，右到左）的样式。
+* [`cssnano`] 是一个模块化的 CSS 压缩器。
+* [`lost`] 是一个功能强大的 `calc()` 栅格系统。
+* [`rtlcss`] 镜像翻转 CSS 样式，适用于 right-to-left 的应用场景。
+
+[`postcss-inline-svg`]:         https://github.com/TrySound/postcss-inline-svg
+[`postcss-preset-env`]:         https://github.com/jonathantneal/postcss-preset-env
+[`react-css-modules`]:          https://github.com/gajus/react-css-modules
+[`postcss-autoreset`]:          https://github.com/maximkoretskiy/postcss-autoreset
+[`postcss-write-svg`]:          https://github.com/jonathantneal/postcss-write-svg
+[`postcss-utilities`]:          https://github.com/ismamz/postcss-utilities
+[`postcss-initial`]:            https://github.com/maximkoretskiy/postcss-initial
+[`postcss-sprites`]:            https://github.com/2createStudio/postcss-sprites
+[`postcss-modules`]:            https://github.com/outpunk/postcss-modules
+[`postcss-sorting`]:            https://github.com/hudochenkov/postcss-sorting
+[`postcss-assets`]:             https://github.com/assetsjs/postcss-assets
+[开发 PostCSS 插件]:             https://github.com/postcss/postcss/blob/master/docs/writing-a-plugin.md
+[`font-magician`]:              https://github.com/jonathantneal/postcss-font-magician
+[`autoprefixer`]:               https://github.com/postcss/autoprefixer
+[`cq-prolyfill`]:               https://github.com/ausi/cq-prolyfill
+[`postcss-rtl`]:                https://github.com/vkalinichev/postcss-rtl
+[`postcss-use`]:                https://github.com/postcss/postcss-use
+[`css-modules`]:                https://github.com/css-modules/css-modules
+[`colorguard`]:                 https://github.com/SlexAxton/css-colorguard
+[`stylelint`]:                  https://github.com/stylelint/stylelint
+[`stylefmt`]:                   https://github.com/morishitter/stylefmt
+[`cssnano`]:                    http://cssnano.co
+[`precss`]:                     https://github.com/jonathantneal/precss
+[`doiuse`]:                     https://github.com/anandthakker/doiuse
+[`rtlcss`]:                     https://github.com/MohammadYounes/rtlcss
+[`short`]:                      https://github.com/jonathantneal/postcss-short
+[`lost`]:                       https://github.com/peterramsing/lost
+
+## 语法
+
+PostCSS 可以转化样式到任意语法，不仅仅是 CSS。
+如果还没有支持你最喜欢的语法，你可以编写一个解释器以及（或者）一个 stringifier 来拓展 PostCSS。
+
+* [`sugarss`] 是一个以缩进为基础的语法，类似于 Sass 和 Stylus。
+* [`postcss-syntax`] 通过文件扩展名自动切换语法。
+* [`postcss-html`] 解析类 HTML 文件里`<style>`标签中的样式。
+* [`postcss-markdown`] 解析 Markdown 文件里代码块中的样式。
+* [`postcss-jsx`] 解析源文件里模板或对象字面量中的CSS。
+* [`postcss-styled`] 解析源文件里模板字面量中的CSS。
+* [`postcss-scss`] 允许你使用 SCSS *(但并没有将 SCSS 编译到 CSS)*。
+* [`postcss-sass`] 允许你使用 Sass *(但并没有将 Sass 编译到 CSS)*。
+* [`postcss-less`] 允许你使用 Less *(但并没有将 LESS 编译到 CSS)*。
+* [`postcss-less-engine`] 允许你使用 Less *(并且使用真正的 Less.js 把 LESS 编译到 CSS)*。
+* [`postcss-js`] 允许你在 JS 里编写样式，或者转换成 React 的内联样式／Radium／JSS。
+* [`postcss-safe-parser`] 查找并修复 CSS 语法错误。
+* [`midas`] 将 CSS 字符串转化成高亮的 HTML。
+
+[`postcss-less-engine`]: https://github.com/Crunch/postcss-less
+[`postcss-safe-parser`]: https://github.com/postcss/postcss-safe-parser
+[`postcss-syntax`]:      https://github.com/gucong3000/postcss-syntax
+[`postcss-html`]:        https://github.com/gucong3000/postcss-html
+[`postcss-markdown`]:    https://github.com/gucong3000/postcss-markdown
+[`postcss-jsx`]:         https://github.com/gucong3000/postcss-jsx
+[`postcss-styled`]:      https://github.com/gucong3000/postcss-styled
+[`postcss-scss`]:        https://github.com/postcss/postcss-scss
+[`postcss-sass`]:        https://github.com/AleshaOleg/postcss-sass
+[`postcss-less`]:        https://github.com/webschik/postcss-less
+[`postcss-js`]:          https://github.com/postcss/postcss-js
+[`sugarss`]:             https://github.com/postcss/sugarss
+[`midas`]:               https://github.com/ben-eb/midas
+
+## 文章
+
+* [一些你对 PostCSS 可能产生的误解](http://julian.io/some-things-you-may-think-about-postcss-and-you-might-be-wrong)
+* [PostCSS 究竟是什么，是做什么的](http://davidtheclark.com/its-time-for-everyone-to-learn-about-postcss)
+* [PostCSS 指南](http://webdesign.tutsplus.com/series/postcss-deep-dive--cms-889)
+
+你可以在 [awesome-postcss](https://github.com/jjaderg/awesome-postcss) 列表里找到更多优秀的文章和视频。
+
+## 书籍
+
+* Alex Libby, Packt 的 [网页设计之精通 PostCSS](https://www.packtpub.com/web-development/mastering-postcss-web-design) (2016年6月)
+
+## 使用方法
+
+你可以通过简单的两步便开始使用 PostCSS：
+
+1. 在你的构建工具中查找并添加 PostCSS 拓展。
+2. [选择插件]并将它们添加到你的 PostCSS 处理队列中。
+
+[选择插件]: http://postcss.parts
+
+### Webpack
+
+在 `webpack.config.js` 里使用 [`postcss-loader`] :
+
+```js
+module.exports = {
+    module: {
+        rules: [
+            {
+                test: /\.css$/,
+                exclude: /node_modules/,
+                use: [
+                    {
+                        loader: 'style-loader',
+                    },
+                    {
+                        loader: 'css-loader',
+                        options: {
+                            importLoaders: 1,
+                        }
+                    },
+                    {
+                        loader: 'postcss-loader'
+                    }
+                ]
+            }
+        ]
+    }
+}
+```
+
+然后创建 `postcss.config.js`:
+
+```js
+module.exports = {
+    plugins: [
+        require('precss'),
+        require('autoprefixer')
+    ]
+}
+```
+
+[`postcss-loader`]: https://github.com/postcss/postcss-loader
+
+### Gulp
+
+使用 [`gulp-postcss`] 和 [`gulp-sourcemaps`].
+
+```js
+gulp.task('css', function () {
+    var postcss    = require('gulp-postcss');
+    var sourcemaps = require('gulp-sourcemaps');
+
+    return gulp.src('src/**/*.css')
+        .pipe( sourcemaps.init() )
+        .pipe( postcss([ require('precss'), require('autoprefixer') ]) )
+        .pipe( sourcemaps.write('.') )
+        .pipe( gulp.dest('build/') );
+});
+```
+
+[`gulp-sourcemaps`]: https://github.com/floridoo/gulp-sourcemaps
+[`gulp-postcss`]:    https://github.com/postcss/gulp-postcss
+
+### npm run / CLI
+
+如果需要在你的命令行界面或 npm 脚本里使用 PostCSS，你可以使用 [`postcss-cli`]。
+
+```sh
+postcss --use autoprefixer -c options.json -o main.css css/*.css
+```
+
+[`postcss-cli`]: https://github.com/postcss/postcss-cli
+
+### 浏览器
+
+如果你想编译浏览器里的 CSS 字符串（例如像 CodePen 一样的在线编辑器），
+只需使用 [Browserify] 或  [webpack]。它们会把 PostCSS 和插件文件打包进一个独立文件。
+
+如果想要在 React 内联样式／JSS／Radium／其它 [CSS-in-JS] 里使用 PostCSS，
+你可以用 [`postcss-js`] 然后转换样式对象。
+
+```js
+var postcss  = require('postcss-js');
+var prefixer = postcss.sync([ require('autoprefixer') ]);
+
+prefixer({ display: 'flex' }); //=> { display: ['-webkit-box', '-webkit-flex', '-ms-flexbox', 'flex'] }
+```
+
+[`postcss-js`]: https://github.com/postcss/postcss-js
+[Browserify]:   http://browserify.org/
+[CSS-in-JS]:    https://github.com/MicheleBertoli/css-in-js
+[webpack]:      https://webpack.github.io/
+
+### 运行器
+
+* **Grunt**: [`grunt-postcss`](https://github.com/nDmitry/grunt-postcss)
+* **HTML**: [`posthtml-postcss`](https://github.com/posthtml/posthtml-postcss)
+* **Stylus**: [`poststylus`](https://github.com/seaneking/poststylus)
+* **Rollup**: [`rollup-plugin-postcss`](https://github.com/egoist/rollup-plugin-postcss)
+* **Brunch**: [`postcss-brunch`](https://github.com/brunch/postcss-brunch)
+* **Broccoli**: [`broccoli-postcss`](https://github.com/jeffjewiss/broccoli-postcss)
+* **Meteor**: [`postcss`](https://atmospherejs.com/juliancwirko/postcss)
+* **ENB**: [`enb-postcss`](https://github.com/awinogradov/enb-postcss)
+* **Taskr**: [`taskr-postcss`](https://github.com/lukeed/taskr/tree/master/packages/postcss)
+* **Start**: [`start-postcss`](https://github.com/start-runner/postcss)
+* **Connect/Express**: [`postcss-middleware`](https://github.com/jedmao/postcss-middleware)
+
+### JS API
+
+对于其它的应用环境，你可以使用 JS API：
+
+```js
+const fs = require('fs');
+const postcss = require('postcss');
+const precss = require('precss');
+const autoprefixer = require('autoprefixer');
+
+fs.readFile('src/app.css', (err, css) => {
+    postcss([precss, autoprefixer])
+        .process(css, { from: 'src/app.css', to: 'dest/app.css' })
+        .then(result => {
+            fs.writeFile('dest/app.css', result.css);
+            if ( result.map ) fs.writeFile('dest/app.css.map', result.map);
+        });
+});
+```
+
+阅读 [PostCSS API 文档] 获取更多有关 JS API 的信息.
+
+所有的 PostCSS 运行器应当通过 [PostCSS 运行器指南]。
+
+[PostCSS 运行器指南]: https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md
+[PostCSS API 文档]:  http://api.postcss.org/postcss.html
+
+### 配置选项
+
+绝大多数 PostCSS 运行器接受两个参数：
+
+* 一个包含所需插件的数组
+* 一个配置选项的对象
+
+常见的选项：
+
+* `syntax`: 一个提供了语法解释器和 stringifier 的对象。
+* `parser`: 一个特殊的语法解释器（例如 [SCSS]）。
+* `stringifier`: 一个特殊的语法 output 生成器（例如 [Midas]）。
+* `map`: [source map 选项].
+* `from`: input 文件名称（大多数运行器自动设置了这个）。
+* `to`: output 文件名称（大多数运行器自动设置了这个）。
+
+[source map 选项]: https://github.com/postcss/postcss/blob/master/docs/source-maps.md
+[Midas]:          https://github.com/ben-eb/midas
+[SCSS]:           https://github.com/postcss/postcss-scss
+
+### Atom
+
+* [`language-postcss`] 添加了 PostCSS 和 [SugarSS] 代码高亮。
+* [`source-preview-postcss`] 在一个独立窗口里实时预览生成的 CSS。
+
+[SugarSS]: https://github.com/postcss/sugarss
+
+### Sublime Text
+
+* [`Syntax-highlighting-for-PostCSS`] 添加了 PostCSS 代码高亮。
+
+[`Syntax-highlighting-for-PostCSS`]: https://github.com/hudochenkov/Syntax-highlighting-for-PostCSS
+[`source-preview-postcss`]:          https://atom.io/packages/source-preview-postcss
+[`language-postcss`]:                https://atom.io/packages/language-postcss
+
+### Vim
+
+* [`postcss.vim`] 添加了 PostCSS 代码高亮。
+
+[`postcss.vim`]: https://github.com/stephenway/postcss.vim
+
+### WebStorm
+
+自 WebStorm 2016.3 开始，[提供了] 内建的 PostCSS 支持。
+
+[提供了]: https://blog.jetbrains.com/webstorm/2016/08/webstorm-2016-3-early-access-preview/

node_modules/@vue/cli-service/node_modules/postcss/README.md

@@ -0,0 +1,376 @@
+# PostCSS [![Gitter][chat-img]][chat]
+
+<img align="right" width="95" height="95"
+     alt="Philosopher’s stone, logo of PostCSS"
+     src="http://postcss.github.io/postcss/logo.svg">
+
+[chat-img]: https://img.shields.io/badge/Gitter-Join_the_PostCSS_chat-brightgreen.svg
+[chat]:     https://gitter.im/postcss/postcss
+
+PostCSS is a tool for transforming styles with JS plugins.
+These plugins can lint your CSS, support variables and mixins,
+transpile future CSS syntax, inline images, and more.
+
+PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba,
+and JetBrains. The [Autoprefixer] PostCSS plugin is one of the most popular
+CSS processors.
+
+PostCSS takes a CSS file and provides an API to analyze and modify its rules
+(by transforming them into an [Abstract Syntax Tree]).
+This API can then be used by [plugins] to do a lot of useful things,
+e.g. to find errors automatically insert vendor prefixes.
+
+**Support / Discussion:** [Gitter](https://gitter.im/postcss/postcss)<br>
+**Twitter account:**      [@postcss](https://twitter.com/postcss)<br>
+**VK.com page:**          [postcss](https://vk.com/postcss)<br>
+**中文翻译**:              [`README-cn.md`](./README-cn.md)
+
+For PostCSS commercial support (consulting, improving the front-end culture
+of your company, PostCSS plugins), contact [Evil Martians](https://evilmartians.com/?utm_source=postcss)
+at <surrender@evilmartians.com>.
+
+[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[Autoprefixer]:         https://github.com/postcss/autoprefixer
+[plugins]:              https://github.com/postcss/postcss#plugins
+
+<a href="https://evilmartians.com/?utm_source=postcss">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+## Plugins
+
+Currently, PostCSS has more than 200 plugins. You can find all of the plugins
+in the [plugins list] or in the [searchable catalog]. Below is a list
+of our favorite plugins — the best demonstrations of what can be built
+on top of PostCSS.
+
+If you have any new ideas, [PostCSS plugin development] is really easy.
+
+[searchable catalog]: http://postcss.parts
+[plugins list]:       https://github.com/postcss/postcss/blob/master/docs/plugins.md
+
+### Solve Global CSS Problem
+
+* [`postcss-use`] allows you to explicitly set PostCSS plugins within CSS
+  and execute them only for the current file.
+* [`postcss-modules`] and [`react-css-modules`] automatically isolate
+  selectors within components.
+* [`postcss-autoreset`] is an alternative to using a global reset
+  that is better for isolatable components.
+* [`postcss-initial`] adds `all: initial` support, which resets
+  all inherited styles.
+* [`cq-prolyfill`] adds container query support, allowing styles that respond
+  to the width of the parent.
+
+### Use Future CSS, Today
+
+* [`autoprefixer`] adds vendor prefixes, using data from Can I Use.
+* [`postcss-preset-env`] allows you to use future CSS features today.
+
+### Better CSS Readability
+
+* [`precss`] contains plugins for Sass-like features, like variables, nesting,
+  and mixins.
+* [`postcss-sorting`] sorts the content of rules and at-rules.
+* [`postcss-utilities`] includes the most commonly used shortcuts and helpers.
+* [`short`] adds and extends numerous shorthand properties.
+
+### Images and Fonts
+
+* [`postcss-assets`] inserts image dimensions and inlines files.
+* [`postcss-sprites`] generates image sprites.
+* [`font-magician`] generates all the `@font-face` rules needed in CSS.
+* [`postcss-inline-svg`] allows you to inline SVG and customize its styles.
+* [`postcss-write-svg`] allows you to write simple SVG directly in your CSS.
+
+### Linters
+
+* [`stylelint`] is a modular stylesheet linter.
+* [`stylefmt`] is a tool that automatically formats CSS
+  according `stylelint` rules.
+* [`doiuse`] lints CSS for browser support, using data from Can I Use.
+* [`colorguard`] helps you maintain a consistent color palette.
+
+### Other
+
+* [`postcss-rtl`] combines both-directional (left-to-right and right-to-left) styles in one CSS file.
+* [`cssnano`] is a modular CSS minifier.
+* [`lost`] is a feature-rich `calc()` grid system.
+* [`rtlcss`] mirrors styles for right-to-left locales.
+
+[PostCSS plugin development]:   https://github.com/postcss/postcss/blob/master/docs/writing-a-plugin.md
+[`postcss-inline-svg`]:         https://github.com/TrySound/postcss-inline-svg
+[`postcss-preset-env`]:         https://github.com/jonathantneal/postcss-preset-env
+[`react-css-modules`]:          https://github.com/gajus/react-css-modules
+[`postcss-autoreset`]:          https://github.com/maximkoretskiy/postcss-autoreset
+[`postcss-write-svg`]:          https://github.com/jonathantneal/postcss-write-svg
+[`postcss-utilities`]:          https://github.com/ismamz/postcss-utilities
+[`postcss-initial`]:            https://github.com/maximkoretskiy/postcss-initial
+[`postcss-sprites`]:            https://github.com/2createStudio/postcss-sprites
+[`postcss-modules`]:            https://github.com/outpunk/postcss-modules
+[`postcss-sorting`]:            https://github.com/hudochenkov/postcss-sorting
+[`postcss-assets`]:             https://github.com/assetsjs/postcss-assets
+[`font-magician`]:              https://github.com/jonathantneal/postcss-font-magician
+[`autoprefixer`]:               https://github.com/postcss/autoprefixer
+[`cq-prolyfill`]:               https://github.com/ausi/cq-prolyfill
+[`postcss-rtl`]:                https://github.com/vkalinichev/postcss-rtl
+[`postcss-use`]:                https://github.com/postcss/postcss-use
+[`css-modules`]:                https://github.com/css-modules/css-modules
+[`colorguard`]:                 https://github.com/SlexAxton/css-colorguard
+[`stylelint`]:                  https://github.com/stylelint/stylelint
+[`stylefmt`]:                   https://github.com/morishitter/stylefmt
+[`cssnano`]:                    http://cssnano.co
+[`precss`]:                     https://github.com/jonathantneal/precss
+[`doiuse`]:                     https://github.com/anandthakker/doiuse
+[`rtlcss`]:                     https://github.com/MohammadYounes/rtlcss
+[`short`]:                      https://github.com/jonathantneal/postcss-short
+[`lost`]:                       https://github.com/peterramsing/lost
+
+## Syntaxes
+
+PostCSS can transform styles in any syntax, not just CSS.
+If there is not yet support for your favorite syntax,
+you can write a parser and/or stringifier to extend PostCSS.
+
+* [`sugarss`] is a indent-based syntax like Sass or Stylus.
+* [`postcss-syntax`] switch syntax automatically by file extensions.
+* [`postcss-html`] parsing styles in `<style>` tags of HTML-like files.
+* [`postcss-markdown`] parsing styles in code blocks of Markdown files.
+* [`postcss-jsx`] parsing CSS in template / object literals of source files.
+* [`postcss-styled`] parsing CSS in template literals of source files.
+* [`postcss-scss`] allows you to work with SCSS
+  *(but does not compile SCSS to CSS)*.
+* [`postcss-sass`] allows you to work with Sass
+    *(but does not compile Sass to CSS)*.
+* [`postcss-less`] allows you to work with Less
+  *(but does not compile LESS to CSS)*.
+* [`postcss-less-engine`] allows you to work with Less
+  *(and DOES compile LESS to CSS using true Less.js evaluation)*.
+* [`postcss-js`] allows you to write styles in JS or transform
+  React Inline Styles, Radium or JSS.
+* [`postcss-safe-parser`] finds and fixes CSS syntax errors.
+* [`midas`] converts a CSS string to highlighted HTML.
+
+[`postcss-less-engine`]: https://github.com/Crunch/postcss-less
+[`postcss-safe-parser`]: https://github.com/postcss/postcss-safe-parser
+[`postcss-syntax`]:      https://github.com/gucong3000/postcss-syntax
+[`postcss-html`]:        https://github.com/gucong3000/postcss-html
+[`postcss-markdown`]:    https://github.com/gucong3000/postcss-markdown
+[`postcss-jsx`]:         https://github.com/gucong3000/postcss-jsx
+[`postcss-styled`]:      https://github.com/gucong3000/postcss-styled
+[`postcss-scss`]:        https://github.com/postcss/postcss-scss
+[`postcss-sass`]:        https://github.com/AleshaOleg/postcss-sass
+[`postcss-less`]:        https://github.com/webschik/postcss-less
+[`postcss-js`]:          https://github.com/postcss/postcss-js
+[`sugarss`]:             https://github.com/postcss/sugarss
+[`midas`]:               https://github.com/ben-eb/midas
+
+## Articles
+
+* [Some things you may think about PostCSS… and you might be wrong](http://julian.io/some-things-you-may-think-about-postcss-and-you-might-be-wrong)
+* [What PostCSS Really Is; What It Really Does](http://davidtheclark.com/its-time-for-everyone-to-learn-about-postcss)
+* [PostCSS Guides](http://webdesign.tutsplus.com/series/postcss-deep-dive--cms-889)
+
+More articles and videos you can find on [awesome-postcss](https://github.com/jjaderg/awesome-postcss) list.
+
+## Books
+
+* [Mastering PostCSS for Web Design](https://www.packtpub.com/web-development/mastering-postcss-web-design) by Alex Libby, Packt. (June 2016)
+
+## Usage
+
+You can start using PostCSS in just two steps:
+
+1. Find and add PostCSS extensions for your build tool.
+2. [Select plugins] and add them to your PostCSS process.
+
+[Select plugins]: http://postcss.parts
+
+### Webpack
+
+Use [`postcss-loader`] in `webpack.config.js`:
+
+```js
+module.exports = {
+    module: {
+        rules: [
+            {
+                test: /\.css$/,
+                exclude: /node_modules/,
+                use: [
+                    {
+                        loader: 'style-loader',
+                    },
+                    {
+                        loader: 'css-loader',
+                        options: {
+                            importLoaders: 1,
+                        }
+                    },
+                    {
+                        loader: 'postcss-loader'
+                    }
+                ]
+            }
+        ]
+    }
+}
+```
+
+Then create `postcss.config.js`:
+
+```js
+module.exports = {
+    plugins: [
+        require('precss'),
+        require('autoprefixer')
+    ]
+}
+```
+
+[`postcss-loader`]: https://github.com/postcss/postcss-loader
+
+### Gulp
+
+Use [`gulp-postcss`] and [`gulp-sourcemaps`].
+
+```js
+gulp.task('css', function () {
+    var postcss    = require('gulp-postcss');
+    var sourcemaps = require('gulp-sourcemaps');
+
+    return gulp.src('src/**/*.css')
+        .pipe( sourcemaps.init() )
+        .pipe( postcss([ require('precss'), require('autoprefixer') ]) )
+        .pipe( sourcemaps.write('.') )
+        .pipe( gulp.dest('build/') );
+});
+```
+
+[`gulp-sourcemaps`]: https://github.com/floridoo/gulp-sourcemaps
+[`gulp-postcss`]:    https://github.com/postcss/gulp-postcss
+
+### npm run / CLI
+
+To use PostCSS from your command-line interface or with npm scripts
+there is [`postcss-cli`].
+
+```sh
+postcss --use autoprefixer -c options.json -o main.css css/*.css
+```
+
+[`postcss-cli`]: https://github.com/postcss/postcss-cli
+
+### Browser
+
+If you want to compile CSS string in browser (for instance, in live edit
+tools like CodePen), just use [Browserify] or [webpack]. They will pack
+PostCSS and plugins files into a single file.
+
+To apply PostCSS plugins to React Inline Styles, JSS, Radium
+and other [CSS-in-JS], you can use [`postcss-js`] and transforms style objects.
+
+```js
+var postcss  = require('postcss-js');
+var prefixer = postcss.sync([ require('autoprefixer') ]);
+
+prefixer({ display: 'flex' }); //=> { display: ['-webkit-box', '-webkit-flex', '-ms-flexbox', 'flex'] }
+```
+
+[`postcss-js`]: https://github.com/postcss/postcss-js
+[Browserify]:   http://browserify.org/
+[CSS-in-JS]:    https://github.com/MicheleBertoli/css-in-js
+[webpack]:      https://webpack.github.io/
+
+### Runners
+
+* **Grunt**: [`grunt-postcss`](https://github.com/nDmitry/grunt-postcss)
+* **HTML**: [`posthtml-postcss`](https://github.com/posthtml/posthtml-postcss)
+* **Stylus**: [`poststylus`](https://github.com/seaneking/poststylus)
+* **Rollup**: [`rollup-plugin-postcss`](https://github.com/egoist/rollup-plugin-postcss)
+* **Brunch**: [`postcss-brunch`](https://github.com/brunch/postcss-brunch)
+* **Broccoli**: [`broccoli-postcss`](https://github.com/jeffjewiss/broccoli-postcss)
+* **Meteor**: [`postcss`](https://atmospherejs.com/juliancwirko/postcss)
+* **ENB**: [`enb-postcss`](https://github.com/awinogradov/enb-postcss)
+* **Taskr**: [`taskr-postcss`](https://github.com/lukeed/taskr/tree/master/packages/postcss)
+* **Start**: [`start-postcss`](https://github.com/start-runner/postcss)
+* **Connect/Express**: [`postcss-middleware`](https://github.com/jedmao/postcss-middleware)
+
+### JS API
+
+For other environments, you can use the JS API:
+
+```js
+const fs = require('fs');
+const postcss = require('postcss');
+const precss = require('precss');
+const autoprefixer = require('autoprefixer');
+
+fs.readFile('src/app.css', (err, css) => {
+    postcss([precss, autoprefixer])
+        .process(css, { from: 'src/app.css', to: 'dest/app.css' })
+        .then(result => {
+            fs.writeFile('dest/app.css', result.css, () => true);
+            if ( result.map ) {
+                fs.writeFile('dest/app.css.map', result.map, () => true);
+            }
+        });
+});
+```
+
+Read the [PostCSS API documentation] for more details about the JS API.
+
+All PostCSS runners should pass [PostCSS Runner Guidelines].
+
+[PostCSS Runner Guidelines]: https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md
+[PostCSS API documentation]: http://api.postcss.org/postcss.html
+
+### Options
+
+Most PostCSS runners accept two parameters:
+
+* An array of plugins.
+* An object of options.
+
+Common options:
+
+* `syntax`: an object providing a syntax parser and a stringifier.
+* `parser`: a special syntax parser (for example, [SCSS]).
+* `stringifier`: a special syntax output generator (for example, [Midas]).
+* `map`: [source map options].
+* `from`: the input file name (most runners set it automatically).
+* `to`: the output file name (most runners set it automatically).
+
+[source map options]: https://github.com/postcss/postcss/blob/master/docs/source-maps.md
+[Midas]:              https://github.com/ben-eb/midas
+[SCSS]:               https://github.com/postcss/postcss-scss
+
+## Editors & IDE Integration
+
+### Atom
+
+* [`language-postcss`] adds PostCSS and [SugarSS] highlight.
+* [`source-preview-postcss`] previews your output CSS in a separate, live pane.
+
+[SugarSS]: https://github.com/postcss/sugarss
+
+### Sublime Text
+
+* [`Syntax-highlighting-for-PostCSS`] adds PostCSS highlight.
+
+[`Syntax-highlighting-for-PostCSS`]: https://github.com/hudochenkov/Syntax-highlighting-for-PostCSS
+[`source-preview-postcss`]:          https://atom.io/packages/source-preview-postcss
+[`language-postcss`]:                https://atom.io/packages/language-postcss
+
+### Vim
+
+* [`postcss.vim`] adds PostCSS highlight.
+
+[`postcss.vim`]: https://github.com/stephenway/postcss.vim
+
+### WebStorm
+
+WebStorm 2016.3 [has] built-in PostCSS support.
+
+[has]: https://blog.jetbrains.com/webstorm/2016/08/webstorm-2016-3-early-access-preview/

node_modules/@vue/cli-service/node_modules/postcss/docs/architecture.md

@@ -0,0 +1,156 @@
+## PostCSS Architecture
+
+General overview of PostCSS architecture.
+It can be useful for everyone who wish to contribute to core or develop better understanding of the tool.
+
+**Table of Contents**
+
+- [Overview](#overview)
+- [Workflow](#workflow)
+- [Core Structures](#core-structures)
+    * [Tokenizer](#tokenizer--libtokenizees6-)
+    * [Parser](#parser--libparsees6-libparseres6-)
+    * [Processor](#processor--libprocessores6-)
+    * [Stringifier](#stringifier--libstringifyes6-libstringifieres6-)
+- [API](#api-reference)
+
+### Overview
+
+> This section describes ideas lying behind PostCSS
+
+Before diving deeper into development of PostCSS let's briefly describe what is PostCSS and what is not.
+
+**PostCSS**
+
+- *is **NOT** a style preprocessor like `Sass` or `Less`.*
+
+    It does not define custom syntax and semantic, it's not actually a language.
+    PostCSS works with CSS and can be easily integrated with tools described above. That being said any valid CSS can be processed by PostCSS.
+
+- *is a tool for CSS syntax transformations*
+
+    It allows you to define custom CSS like syntax that could be understandable and transformed by plugins. That being said PostCSS is not strictly about CSS spec but about syntax definition manner of CSS. In such way you can define custom syntax constructs like at-rule, that could be very helpful for tools build around PostCSS. PostCSS plays a role of framework for building outstanding tools for CSS manipulations.
+
+- *is a big player in CSS ecosystem*
+
+    Large amount of lovely tools like `Autoprefixer`, `Stylelint`, `CSSnano` were built on PostCSS ecosystem. There is big chance that you already use it implicitly, just check your `node_modules` :smiley:
+
+### Workflow
+
+This is high level overview of whole PostCSS workflow
+
+<img width="300" src="https://upload.wikimedia.org/wikipedia/commons/thumb/a/aa/PostCSS_scheme.svg/512px-PostCSS_scheme.svg.png" alt="workflow">
+
+As you can see from diagram above, PostCSS architecture is pretty straightforward but some parts of it could be misunderstood.
+
+From diagram above you can see part called *Parser*, this construct will be described in details later on, just for now think about it as a structure that can understand your CSS like syntax and create object representation of it.
+
+That being said, there are few ways to write parser
+
+ - *Write a single file with string to AST transformation*
+
+    This method is quite popular, for example, the [Rework analyzer](https://github.com/reworkcss/css/blob/master/lib/parse/index.js) was written in this style. But with a large code base, the code becomes hard to read and pretty slow.
+
+ - *Split it into lexical analysis/parsing steps (source string → tokens → AST)*
+
+    This is the way of how we do it in PostCSS and also the most popular one.
+    A lot of parsers like [`Babylon` (parser behind Babel)](https://github.com/babel/babel/tree/master/packages/babylon), [`CSSTree`](https://github.com/csstree/csstree) were written in such way.
+    The main reasons to separate tokenization from parsing steps are performance and abstracting complexity.
+
+Let think about why second way is better for our needs.
+
+First of all because string to tokens step takes more time than parsing step. We operate on large source string and process it char by char, this is why it is very inefficient operation in terms of performance and we should perform it only once.
+
+But from other side tokens to AST transformation is logically more complex so with such separation we could write very fast tokenizer (but from this comes sometimes hard to read code) and easy to read (but slow) parser.
+
+Summing it up splitting in two steps improve performance and code readability.
+
+So now lets look more closely on structures that play main role in PostCSS workflow.
+
+### Core Structures
+
+ - #### Tokenizer ( [lib/tokenize.es6](https://github.com/postcss/postcss/blob/master/lib/tokenize.es6) )
+
+    Tokenizer (aka Lexer) plays important role in syntax analysis.
+
+    It accepts CSS string and returns list of tokens.
+
+    Token is a simple structure that describes some part of syntax like `at-rule`, `comment` or `word`. It can also contain positional information for more descriptive errors.
+
+    For example if we consider following css
+
+    ```css
+    .className { color: #FFF; }
+    ```
+
+    corresponding tokens representation from PostCSS will be
+    ```js
+    [
+        ["word", ".className", 1, 1, 1, 10]
+        ["space", " "]
+        ["{", "{", 1, 12]
+        ["space", " "]
+        ["word", "color", 1, 14, 1, 18]
+        [":", ":", 1, 19]
+        ["space", " "]
+        ["word", "#FFF" , 1, 21, 1, 23]
+        [";", ";", 1, 24]
+        ["space", " "]
+        ["}", "}", 1, 26]
+    ]
+    ```
+
+    As you can see from the example above single token represented as a list and also `space` token doesn't have positional information.
+
+    Lets look more closely on single token like `word`. As it was said each token represented as a list and follow such pattern.
+
+    ```js
+    const token = [
+         // represents token type
+        'word',
+
+        // represents matched word
+        '.className',
+
+        // This two numbers represent start position of token.
+        // It's optional value as we saw in example above,
+        // tokens like `space` don't have such information.
+
+        // Here the first number is line number and the second one is corresponding column.
+        1, 1,
+
+        // Next two numbers also optional and represent end position for multichar tokens like this one. Numbers follow same rule as was described above
+        1, 10
+    ];
+    ```
+   There are many patterns how tokenization could be done, PostCSS motto is performance and simplicity. Tokenization is complex computing operation and take large amount of syntax analysis time ( ~90% ), that why PostCSS' Tokenizer looks dirty but it was optimized for speed. Any high-level constructs like classes could dramatically slow down tokenizer.
+
+    PostCSS' Tokenizer use some sort of streaming/chaining API where you exposes [`nextToken()`](https://github.com/postcss/postcss/blob/master/lib/tokenize.es6#L48-L308) method to Parser. In this manner we provide clean interface for Parser and reduce memory usage by storing only few tokens and not whole list of tokens.
+
+- #### Parser ( [lib/parse.es6](https://github.com/postcss/postcss/blob/master/lib/parse.es6), [lib/parser.es6](https://github.com/postcss/postcss/blob/master/lib/parser.es6) )
+
+    Parser is main structure that responsible for [syntax analysis](https://en.wikipedia.org/wiki/Parsing) of incoming CSS. Parser produces structure called [Abstract Syntax Tree (AST)](https://en.wikipedia.org/wiki/Abstract_syntax_tree) that could then be transformed by plugins later on.
+
+    Parser works in common with Tokenizer and operates over tokens not source string, as it would be very inefficient operation.
+
+    It use mostly `nextToken` and `back` methods provided by Tokenizer for obtaining single or multiple tokens and than construct part of AST called `Node`
+
+    There are multiple Node types that PostCSS could produce but all of them inherit from base Node [class](https://github.com/postcss/postcss/blob/master/lib/node.es6#L34).
+
+- #### Processor ( [lib/processor.es6](https://github.com/postcss/postcss/blob/master/lib/processor.es6) )
+
+    Processor is a very plain structure that initializes plugins and run syntax transformations. Plugin is just a function registered with [postcss.plugin](https://github.com/postcss/postcss/blob/master/lib/postcss.es6#L109) call.
+
+    It exposes quite few public API methods. Description of them could be found on [api.postcss.org/Processor](http://api.postcss.org/Processor.html)
+
+- #### Stringifier ( [lib/stringify.es6](https://github.com/postcss/postcss/blob/master/lib/stringify.es6), [lib/stringifier.es6](https://github.com/postcss/postcss/blob/master/lib/stringifier.es6) )
+
+    Stringifier is a base class that translates modified AST to pure CSS string. Stringifier traverse AST starting from provided Node and generate raw string representation of it calling corresponding methods.
+
+    The most essential method is [`Stringifier.stringify`](https://github.com/postcss/postcss/blob/master/lib/stringifier.es6#L25-L27)
+    that accepts initial Node and semicolon indicator.
+    You can learn more by checking [stringifier.es6](https://github.com/postcss/postcss/blob/master/lib/stringifier.es6)
+
+### API Reference
+
+More descriptive API documentation could be found [here](http://api.postcss.org/)

node_modules/@vue/cli-service/node_modules/postcss/docs/guidelines/plugin.md

@@ -0,0 +1,195 @@
+# PostCSS Plugin Guidelines
+
+A PostCSS plugin is a function that receives and, usually,
+transforms a CSS AST from the PostCSS parser.
+
+The rules below are *mandatory* for all PostCSS plugins.
+
+See also [ClojureWerkz’s recommendations] for open source projects.
+
+[ClojureWerkz’s recommendations]:  http://blog.clojurewerkz.org/blog/2013/04/20/how-to-make-your-open-source-project-really-awesome/
+
+## 1. API
+
+### 1.1 Clear name with `postcss-` prefix
+
+The plugin’s purpose should be clear just by reading its name.
+If you wrote a transpiler for CSS 4 Custom Media, `postcss-custom-media`
+would be a good name. If you wrote a plugin to support mixins,
+`postcss-mixins` would be a good name.
+
+The prefix `postcss-` shows that the plugin is part of the PostCSS ecosystem.
+
+This rule is not mandatory for plugins that can run as independent tools,
+without the user necessarily knowing that it is powered by
+PostCSS — for example, [cssnext] and [Autoprefixer].
+
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+[cssnext]:      http://cssnext.io/
+
+### 1.2. Do one thing, and do it well
+
+Do not create multitool plugins. Several small, one-purpose plugins bundled into
+a plugin pack is usually a better solution.
+
+For example, [cssnext] contains many small plugins,
+one for each W3C specification. And [cssnano] contains a separate plugin
+for each of its optimization.
+
+[cssnext]: http://cssnext.io/
+[cssnano]: https://github.com/ben-eb/cssnano
+
+### 1.3. Do not use mixins
+
+Preprocessors libraries like Compass provide an API with mixins.
+
+PostCSS plugins are different.
+A plugin cannot be just a set of mixins for [postcss-mixins].
+
+To achieve your goal, consider transforming valid CSS
+or using custom at-rules and custom properties.
+
+[postcss-mixins]: https://github.com/postcss/postcss-mixins
+
+### 1.4. Create plugin by `postcss.plugin`
+
+By wrapping your function in this method,
+you are hooking into a common plugin API:
+
+```js
+module.exports = postcss.plugin('plugin-name', function (opts) {
+    return function (root, result) {
+        // Plugin code
+    };
+});
+```
+
+## 2. Processing
+
+### 2.1. Plugin must be tested
+
+A CI service like [Travis] is also recommended for testing code in
+different environments. You should test in (at least) Node.js [active LTS](https://github.com/nodejs/LTS) and current stable version.
+
+[Travis]: https://travis-ci.org/
+
+### 2.2. Use asynchronous methods whenever possible
+
+For example, use `fs.writeFile` instead of `fs.writeFileSync`:
+
+```js
+postcss.plugin('plugin-sprite', function (opts) {
+    return function (root, result) {
+
+        return new Promise(function (resolve, reject) {
+            var sprite = makeSprite();
+            fs.writeFile(opts.file, function (err) {
+                if ( err ) return reject(err);
+                resolve();
+            })
+        });
+
+    };
+});
+```
+
+### 2.3. Set `node.source` for new nodes
+
+Every node must have a relevant `source` so PostCSS can generate
+an accurate source map.
+
+So if you add new declaration based on some existing declaration, you should
+clone the existing declaration in order to save that original `source`.
+
+```js
+if ( needPrefix(decl.prop) ) {
+    decl.cloneBefore({ prop: '-webkit-' + decl.prop });
+}
+```
+
+You can also set `source` directly, copying from some existing node:
+
+```js
+if ( decl.prop === 'animation' ) {
+    var keyframe = createAnimationByName(decl.value);
+    keyframes.source = decl.source;
+    decl.root().append(keyframes);
+}
+```
+
+### 2.4. Use only the public PostCSS API
+
+PostCSS plugins must not rely on undocumented properties or methods,
+which may be subject to change in any minor release. The public API
+is described in [API docs].
+
+[API docs]: http://api.postcss.org/
+
+## 3. Errors
+
+### 3.1. Use `node.error` on CSS relevant errors
+
+If you have an error because of input CSS (like an unknown name
+in a mixin plugin) you should use `node.error` to create an error
+that includes source position:
+
+```js
+if ( typeof mixins[name] === 'undefined' ) {
+    throw decl.error('Unknown mixin ' + name, { plugin: 'postcss-mixins' });
+}
+```
+
+### 3.2. Use `result.warn` for warnings
+
+Do not print warnings with `console.log` or `console.warn`,
+because some PostCSS runner may not allow console output.
+
+```js
+if ( outdated(decl.prop) ) {
+    result.warn(decl.prop + ' is outdated', { node: decl });
+}
+```
+
+If CSS input is a source of the warning, the plugin must set the `node` option.
+
+## 4. Documentation
+
+### 4.1. Document your plugin in English
+
+PostCSS plugins must have their `README.md` written in English. Do not be afraid
+of your English skills, as the open source community will fix your errors.
+
+Of course, you are welcome to write documentation in other languages;
+just name them appropriately (e.g. `README.ja.md`).
+
+### 4.2. Include input and output examples
+
+The plugin's `README.md` must contain example input and output CSS.
+A clear example is the best way to describe how your plugin works.
+
+The first section of the `README.md` is a good place to put examples.
+See [postcss-opacity](https://github.com/iamvdo/postcss-opacity) for an example.
+
+Of course, this guideline does not apply if your plugin does not
+transform the CSS.
+
+### 4.3. Maintain a changelog
+
+PostCSS plugins must describe the changes of all their releases
+in a separate file, such as `CHANGELOG.md`, `History.md`, or [GitHub Releases].
+Visit [Keep A Changelog] for more information about how to write one of these.
+
+Of course, you should be using [SemVer].
+
+[Keep A Changelog]: http://keepachangelog.com/
+[GitHub Releases]:  https://help.github.com/articles/creating-releases/
+[SemVer]:           http://semver.org/
+
+### 4.4. Include `postcss-plugin` keyword in `package.json`
+
+PostCSS plugins written for npm must have the `postcss-plugin` keyword
+in their `package.json`. This special keyword will be useful for feedback about
+the PostCSS ecosystem.
+
+For packages not published to npm, this is not mandatory, but is recommended
+if the package format can contain keywords.

node_modules/@vue/cli-service/node_modules/postcss/docs/guidelines/runner.md

@@ -0,0 +1,143 @@
+# PostCSS Runner Guidelines
+
+A PostCSS runner is a tool that processes CSS through a user-defined list
+of plugins; for example, [`postcss-cli`] or [`gulp‑postcss`].
+These rules are mandatory for any such runners.
+
+For single-plugin tools, like [`gulp-autoprefixer`],
+these rules are not mandatory but are highly recommended.
+
+See also [ClojureWerkz’s recommendations] for open source projects.
+
+[ClojureWerkz’s recommendations]:  http://blog.clojurewerkz.org/blog/2013/04/20/how-to-make-your-open-source-project-really-awesome/
+[`gulp-autoprefixer`]: https://github.com/sindresorhus/gulp-autoprefixer
+[`gulp‑postcss`]:      https://github.com/w0rm/gulp-postcss
+[`postcss-cli`]:       https://github.com/postcss/postcss-cli
+
+## 1. API
+
+### 1.1. Accept functions in plugin parameters
+
+If your runner uses a config file, it must be written in JavaScript, so that
+it can support plugins which accept a function, such as [`postcss-assets`]:
+
+```js
+module.exports = [
+    require('postcss-assets')({
+        cachebuster: function (file) {
+            return fs.statSync(file).mtime.getTime().toString(16);
+        }
+    })
+];
+```
+
+[`postcss-assets`]: https://github.com/borodean/postcss-assets
+
+## 2. Processing
+
+### 2.1. Set `from` and `to` processing options
+
+To ensure that PostCSS generates source maps and displays better syntax errors,
+runners must specify the `from` and `to` options. If your runner does not handle
+writing to disk (for example, a gulp transform), you should set both options
+to point to the same file:
+
+```js
+processor.process({ from: file.path, to: file.path });
+```
+
+### 2.2. Use only the asynchronous API
+
+PostCSS runners must use only the asynchronous API.
+The synchronous API is provided only for debugging, is slower,
+and can’t work with asynchronous plugins.
+
+```js
+processor.process(opts).then(function (result) {
+    // processing is finished
+});
+```
+
+### 2.3. Use only the public PostCSS API
+
+PostCSS runners must not rely on undocumented properties or methods,
+which may be subject to change in any minor release. The public API
+is described in [API docs].
+
+[API docs]: http://api.postcss.org/
+
+## 3. Output
+
+### 3.1. Don’t show JS stack for `CssSyntaxError`
+
+PostCSS runners must not show a stack trace for CSS syntax errors,
+as the runner can be used by developers who are not familiar with JavaScript.
+Instead, handle such errors gracefully:
+
+```js
+processor.process(opts).catch(function (error) {
+    if ( error.name === 'CssSyntaxError' ) {
+        process.stderr.write(error.message + error.showSourceCode());
+    } else {
+        throw error;
+    }
+});
+```
+
+### 3.2. Display `result.warnings()`
+
+PostCSS runners must output warnings from `result.warnings()`:
+
+```js
+result.warnings().forEach(function (warn) {
+    process.stderr.write(warn.toString());
+});
+```
+
+See also [postcss-log-warnings] and [postcss-messages] plugins.
+
+[postcss-log-warnings]: https://github.com/davidtheclark/postcss-log-warnings
+[postcss-messages]:     https://github.com/postcss/postcss-messages
+
+### 3.3. Allow the user to write source maps to different files
+
+PostCSS by default will inline source maps in the generated file; however,
+PostCSS runners must provide an option to save the source map in a different
+file:
+
+```js
+if ( result.map ) {
+    fs.writeFile(opts.to + '.map', result.map.toString());
+}
+```
+
+## 4. Documentation
+
+### 4.1. Document your runner in English
+
+PostCSS runners must have their `README.md` written in English. Do not be afraid
+of your English skills, as the open source community will fix your errors.
+
+Of course, you are welcome to write documentation in other languages;
+just name them appropriately (e.g. `README.ja.md`).
+
+### 4.2. Maintain a changelog
+
+PostCSS runners must describe changes of all releases in a separate file,
+such as `ChangeLog.md`, `History.md`, or with [GitHub Releases].
+Visit [Keep A Changelog] for more information on how to write one of these.
+
+Of course you should use [SemVer].
+
+[Keep A Changelog]: http://keepachangelog.com/
+[GitHub Releases]:  https://help.github.com/articles/creating-releases/
+[SemVer]:           http://semver.org/
+
+### 4.3. `postcss-runner` keyword in `package.json`
+
+PostCSS runners written for npm must have the `postcss-runner` keyword
+in their `package.json`. This special keyword will be useful for feedback about
+the PostCSS ecosystem.
+
+For packages not published to npm, this is not mandatory, but recommended
+if the package format is allowed to contain keywords.

node_modules/@vue/cli-service/node_modules/postcss/docs/source-maps.md

@@ -0,0 +1,74 @@
+# PostCSS and Source Maps
+
+PostCSS has great [source maps] support. It can read and interpret maps
+from previous transformation steps, autodetect the format that you expect,
+and output both external and inline maps.
+
+To ensure that you generate an accurate source map, you must indicate the input
+and output CSS file paths — using the options `from` and `to`, respectively.
+
+To generate a new source map with the default options, simply set `map: true`.
+This will generate an inline source map that contains the source content.
+If you don’t want the map inlined, you can set `map.inline: false`.
+
+```js
+processor
+    .process(css, {
+        from: 'app.sass.css',
+        to:   'app.css',
+        map: { inline: false },
+    })
+    .then(function (result) {
+        result.map //=> '{ "version":3,
+                   //      "file":"app.css",
+                   //      "sources":["app.sass"],
+                   //       "mappings":"AAAA,KAAI" }'
+    });
+```
+
+If PostCSS finds source maps from a previous transformation,
+it will automatically update that source map with the same options.
+
+## Options
+
+If you want more control over source map generation, you can define the `map`
+option as an object with the following parameters:
+
+* `inline` boolean: indicates that the source map should be embedded
+  in the output CSS as a Base64-encoded comment. By default, it is `true`.
+  But if all previous maps are external, not inline, PostCSS will not embed
+  the map even if you do not set this option.
+
+  If you have an inline source map, the `result.map` property will be empty,
+  as the source map will be contained within the text of `result.css`.
+
+* `prev` string, object, boolean or function: source map content from
+  a previous processing step (for example, Sass compilation).
+  PostCSS will try to read the previous source map automatically
+  (based on comments within the source CSS), but you can use this option
+  to identify it manually. If desired, you can omit the previous map
+  with `prev: false`.
+
+* `sourcesContent` boolean: indicates that PostCSS should set the origin
+  content (for example, Sass source) of the source map. By default,
+  it is `true`. But if all previous maps do not contain sources content,
+  PostCSS will also leave it out even if you do not set this option.
+
+* `annotation` boolean or string: indicates that PostCSS should add annotation
+  comments to the CSS. By default, PostCSS will always add a comment with a path
+  to the source map. PostCSS will not add annotations to CSS files that
+  do not contain any comments.
+
+  By default, PostCSS presumes that you want to save the source map as
+  `opts.to + '.map'` and will use this path in the annotation comment.
+  A different path can be set by providing a string value for `annotation`.
+
+  If you have set `inline: true`, annotation cannot be disabled.
+
+* `from` string: by default, PostCSS will set the `sources` property of the map
+  to the value of the `from` option. If you want to override this behaviour, you
+  can use `map.from` to explicitly set the source map's `sources` property.
+  Path should be absolute or relative from generated file
+  (`to` option in `process()` method).
+
+[source maps]: http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/

node_modules/@vue/cli-service/node_modules/postcss/docs/syntax.md

@@ -0,0 +1,231 @@
+# How to Write Custom Syntax
+
+PostCSS can transform styles in any syntax, and is not limited to just CSS.
+By writing a custom syntax, you can transform styles in any desired format.
+
+Writing a custom syntax is much harder than writing a PostCSS plugin, but
+it is an awesome adventure.
+
+There are 3 types of PostCSS syntax packages:
+
+* **Parser** to parse input string to node’s tree.
+* **Stringifier** to generate output string by node’s tree.
+* **Syntax** contains both parser and stringifier.
+
+## Syntax
+
+A good example of a custom syntax is [SCSS]. Some users may want to transform
+SCSS sources with PostCSS plugins, for example if they need to add vendor
+prefixes or change the property order. So this syntax should output SCSS from
+an SCSS input.
+
+The syntax API is a very simple plain object, with `parse` & `stringify`
+functions:
+
+```js
+module.exports = {
+    parse:     require('./parse'),
+    stringify: require('./stringify')
+};
+```
+
+[SCSS]: https://github.com/postcss/postcss-scss
+
+## Parser
+
+A good example of a parser is [Safe Parser], which parses malformed/broken CSS.
+Because there is no point to generate broken output, this package only provides
+a parser.
+
+The parser API is a function which receives a string & returns a [`Root`] node.
+The second argument is a function which receives an object with PostCSS options.
+
+```js
+var postcss = require('postcss');
+
+module.exports = function (css, opts) {
+    var root = postcss.root();
+    // Add other nodes to root
+    return root;
+};
+```
+
+[Safe Parser]: https://github.com/postcss/postcss-safe-parser
+[`Root`]:      http://api.postcss.org/Root.html
+
+### Main Theory
+
+There are many books about parsers; but do not worry because CSS syntax is
+very easy, and so the parser will be much simpler than a programming language
+parser.
+
+The default PostCSS parser contains two steps:
+
+1. [Tokenizer] which reads input string character by character and builds a
+  tokens array. For example, it joins space symbols to a `['space', '\n  ']`
+  token, and detects strings to a `['string', '"\"{"']` token.
+2. [Parser] which reads the tokens array, creates node instances and
+  builds a tree.
+
+[Tokenizer]: https://github.com/postcss/postcss/blob/master/lib/tokenize.es6
+[Parser]:    https://github.com/postcss/postcss/blob/master/lib/parser.es6
+
+### Performance
+
+Parsing input is often the most time consuming task in CSS processors. So it
+is very important to have a fast parser.
+
+The main rule of optimization is that there is no performance without a
+benchmark. You can look at [PostCSS benchmarks] to build your own.
+
+Of parsing tasks, the tokenize step will often take the most time, so its
+performance should be prioritized. Unfortunately, classes, functions and
+high level structures can slow down your tokenizer. Be ready to write dirty
+code with repeated statements. This is why it is difficult to extend the
+default [PostCSS tokenizer]; copy & paste will be a necessary evil.
+
+Second optimization is using character codes instead of strings.
+
+```js
+// Slow
+string[i] === '{';
+
+// Fast
+const OPEN_CURLY = 123; // `{'
+string.charCodeAt(i) === OPEN_CURLY;
+```
+
+Third optimization is “fast jumps”. If you find open quotes, you can find
+next closing quote much faster by `indexOf`:
+
+```js
+// Simple jump
+next = string.indexOf('"', currentPosition + 1);
+
+// Jump by RegExp
+regexp.lastIndex = currentPosion + 1;
+regexp.test(string);
+next = regexp.lastIndex;
+```
+
+The parser can be a well written class. There is no need in copy-paste and
+hardcore optimization there. You can extend the default [PostCSS parser].
+
+[PostCSS benchmarks]: https://github.com/postcss/benchmark
+[PostCSS tokenizer]:  https://github.com/postcss/postcss/blob/master/lib/tokenize.es6
+[PostCSS parser]:     https://github.com/postcss/postcss/blob/master/lib/parser.es6
+
+### Node Source
+
+Every node should have `source` property to generate correct source map.
+This property contains `start` and `end` properties with `{ line, column }`,
+and `input` property with an [`Input`] instance.
+
+Your tokenizer should save the original position so that you can propagate
+the values to the parser, to ensure that the source map is correctly updated.
+
+[`Input`]: https://github.com/postcss/postcss/blob/master/lib/input.es6
+
+### Raw Values
+
+A good PostCSS parser should provide all information (including spaces symbols)
+to generate byte-to-byte equal output. It is not so difficult, but respectful
+for user input and allow integration smoke tests.
+
+A parser should save all additional symbols to `node.raws` object.
+It is an open structure for you, you can add additional keys.
+For example, [SCSS parser] saves comment types (`/* */` or `//`)
+in `node.raws.inline`.
+
+The default parser cleans CSS values from comments and spaces.
+It saves the original value with comments to `node.raws.value.raw` and uses it,
+if the node value was not changed.
+
+[SCSS parser]: https://github.com/postcss/postcss-scss
+
+### Tests
+
+Of course, all parsers in the PostCSS ecosystem must have tests.
+
+If your parser just extends CSS syntax (like [SCSS] or [Safe Parser]),
+you can use the [PostCSS Parser Tests]. It contains unit & integration tests.
+
+[PostCSS Parser Tests]: https://github.com/postcss/postcss-parser-tests
+
+## Stringifier
+
+A style guide generator is a good example of a stringifier. It generates output
+HTML which contains CSS components. For this use case, a parser isn't necessary,
+so the package should just contain a stringifier.
+
+The Stringifier API is little bit more complicated, than the parser API.
+PostCSS generates a source map, so a stringifier can’t just return a string.
+It must link every substring with its source node.
+
+A Stringifier is a function which receives [`Root`] node and builder callback.
+Then it calls builder with every node’s string and node instance.
+
+```js
+module.exports = function (root, builder) {
+    // Some magic
+    var string = decl.prop + ':' + decl.value + ';';
+    builder(string, decl);
+    // Some science
+};
+```
+
+### Main Theory
+
+PostCSS [default stringifier] is just a class with a method for each node type
+and many methods to detect raw properties.
+
+In most cases it will be enough just to extend this class,
+like in [SCSS stringifier].
+
+[default stringifier]: https://github.com/postcss/postcss/blob/master/lib/stringifier.es6
+[SCSS stringifier]:    https://github.com/postcss/postcss-scss/blob/master/lib/scss-stringifier.es6
+
+### Builder Function
+
+A builder function will be passed to `stringify` function as second argument.
+For example, the default PostCSS stringifier class saves it
+to `this.builder` property.
+
+Builder receives output substring and source node to append this substring
+to the final output.
+
+Some nodes contain other nodes in the middle. For example, a rule has a `{`
+at the beginning, many declarations inside and a closing `}`.
+
+For these cases, you should pass a third argument to builder function:
+`'start'` or `'end'` string:
+
+```js
+this.builder(rule.selector + '{', rule, 'start');
+// Stringify declarations inside
+this.builder('}', rule, 'end');
+```
+
+### Raw Values
+
+A good PostCSS custom syntax saves all symbols and provide byte-to-byte equal
+output if there were no changes.
+
+This is why every node has `node.raws` object to store space symbol, etc.
+
+Be careful, because sometimes these raw properties will not be present; some
+nodes may be built manually, or may lose their indentation when they are moved
+to another parent node.
+
+This is why the default stringifier has a `raw()` method to autodetect raw
+properties by other nodes. For example, it will look at other nodes to detect
+indent size and them multiply it with the current node depth.
+
+### Tests
+
+A stringifier must have tests too.
+
+You can use unit and integration test cases from [PostCSS Parser Tests].
+Just compare input CSS with CSS after your parser and stringifier.
+
+[PostCSS Parser Tests]: https://github.com/postcss/postcss-parser-tests

node_modules/@vue/cli-service/node_modules/postcss/gulpfile.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const gulp = require('gulp');
+
+gulp.task('clean', () => {
+    let del = require('del');
+    return del(['lib/*.js', 'postcss.js', 'build/', 'api/']);
+});
+
+// Build
+
+gulp.task('compile', () => {
+    let sourcemaps = require('gulp-sourcemaps');
+    let changed    = require('gulp-changed');
+    let babel      = require('gulp-babel');
+    return gulp.src('lib/*.es6')
+        .pipe(changed('lib', { extension: '.js' }))
+        .pipe(sourcemaps.init())
+        .pipe(babel({
+            presets: [
+                [
+                    'env',
+                    {
+                        targets: {
+                            browsers: 'last 2 version',
+                            node: 4
+                        },
+                        loose: true
+                    }
+                ]
+            ],
+            plugins: ['add-module-exports', 'precompile-charcodes']
+        }))
+        .pipe(sourcemaps.write())
+        .pipe(gulp.dest('lib'));
+});
+
+gulp.task('build:lib', ['compile'], () => {
+    return gulp.src(['lib/*.js', 'lib/*.d.ts']).pipe(gulp.dest('build/lib'));
+});
+
+gulp.task('build:package', () => {
+    const editor = require('gulp-json-editor');
+    return gulp.src('./package.json')
+        .pipe(editor((json) => {
+            delete json.babel;
+            delete json.scripts;
+            delete json.jest;
+            delete json.eslintConfig;
+            delete json['size-limit'];
+            delete json['pre-commit'];
+            delete json['lint-staged'];
+            delete json.devDependencies;
+            return json;
+        }))
+        .pipe(gulp.dest('build'));
+});
+
+gulp.task('build:docs', () => {
+    let ignore = require('fs').readFileSync('.npmignore').toString()
+        .trim().split(/\n+/)
+        .concat([
+            'package.json', '.npmignore', 'lib/*', 'test/*',
+            'node_modules/**/*', 'docs/api.md', 'docs/plugins.md',
+            'docs/writing-a-plugin.md'
+        ]).map( i => '!' + i );
+    return gulp.src(['**/*'].concat(ignore))
+        .pipe(gulp.dest('build'));
+});
+
+gulp.task('build', done => {
+    let runSequence = require('run-sequence');
+    runSequence('clean', ['build:lib', 'build:docs', 'build:package'], done);
+});
+
+// Tests
+
+gulp.task('integration', ['build'], done => {
+    let postcss = require('./build');
+    let real    = require('postcss-parser-tests/real');
+    real(done, css => {
+        return postcss.parse(css).toResult({ map: { annotation: false } });
+    });
+});
+
+gulp.task('version', ['build:lib'], () => {
+    let Processor = require('./lib/processor');
+    let instance  = new Processor();
+    let pkg       = require('./package');
+    if ( pkg.version !== instance.version ) {
+        throw new Error('Version in Processor is not equal to package.json');
+    }
+});
+
+// Common
+
+gulp.task('default', ['version', 'integration']);

node_modules/@vue/cli-service/node_modules/postcss/lib/comment.js

@@ -0,0 +1,61 @@
+'use strict';
+
+exports.__esModule = true;
+
+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; }
+
+/**
+ * Represents a comment between declarations or statements (rule and at-rules).
+ *
+ * Comments inside selectors, at-rule parameters, or declaration values
+ * will be stored in the `raws` properties explained above.
+ *
+ * @extends Node
+ */
+var Comment = function (_Node) {
+  _inherits(Comment, _Node);
+
+  function Comment(defaults) {
+    _classCallCheck(this, Comment);
+
+    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));
+
+    _this.type = 'comment';
+    return _this;
+  }
+
+  /**
+   * @memberof Comment#
+   * @member {string} text - the comment’s text
+   */
+
+  /**
+   * @memberof Comment#
+   * @member {object} raws - Information to generate byte-to-byte equal
+   *                         node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node.
+   * * `left`: the space symbols between `/*` and the comment’s text.
+   * * `right`: the space symbols between the comment’s text.
+   */
+
+
+  return Comment;
+}(_node2.default);
+
+exports.default = Comment;
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1lbnQuZXM2Il0sIm5hbWVzIjpbIkNvbW1lbnQiLCJkZWZhdWx0cyIsInR5cGUiLCJOb2RlIl0sIm1hcHBpbmdzIjoiOzs7O0FBQUE7Ozs7Ozs7Ozs7OztBQUVBOzs7Ozs7OztJQVFNQSxPOzs7QUFFRixtQkFBWUMsUUFBWixFQUFzQjtBQUFBOztBQUFBLGlEQUNsQixpQkFBTUEsUUFBTixDQURrQjs7QUFFbEIsVUFBS0MsSUFBTCxHQUFZLFNBQVo7QUFGa0I7QUFHckI7O0FBRUQ7Ozs7O0FBS0E7Ozs7Ozs7Ozs7Ozs7OztFQVprQkMsYzs7a0JBMEJQSCxPIiwiZmlsZSI6ImNvbW1lbnQuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTm9kZSBmcm9tICcuL25vZGUnO1xuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBjb21tZW50IGJldHdlZW4gZGVjbGFyYXRpb25zIG9yIHN0YXRlbWVudHMgKHJ1bGUgYW5kIGF0LXJ1bGVzKS5cbiAqXG4gKiBDb21tZW50cyBpbnNpZGUgc2VsZWN0b3JzLCBhdC1ydWxlIHBhcmFtZXRlcnMsIG9yIGRlY2xhcmF0aW9uIHZhbHVlc1xuICogd2lsbCBiZSBzdG9yZWQgaW4gdGhlIGByYXdzYCBwcm9wZXJ0aWVzIGV4cGxhaW5lZCBhYm92ZS5cbiAqXG4gKiBAZXh0ZW5kcyBOb2RlXG4gKi9cbmNsYXNzIENvbW1lbnQgZXh0ZW5kcyBOb2RlIHtcblxuICAgIGNvbnN0cnVjdG9yKGRlZmF1bHRzKSB7XG4gICAgICAgIHN1cGVyKGRlZmF1bHRzKTtcbiAgICAgICAgdGhpcy50eXBlID0gJ2NvbW1lbnQnO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEBtZW1iZXJvZiBDb21tZW50I1xuICAgICAqIEBtZW1iZXIge3N0cmluZ30gdGV4dCAtIHRoZSBjb21tZW504oCZcyB0ZXh0XG4gICAgICovXG5cbiAgICAvKipcbiAgICAgKiBAbWVtYmVyb2YgQ29tbWVudCNcbiAgICAgKiBAbWVtYmVyIHtvYmplY3R9IHJhd3MgLSBJbmZvcm1hdGlvbiB0byBnZW5lcmF0ZSBieXRlLXRvLWJ5dGUgZXF1YWxcbiAgICAgKiAgICAgICAgICAgICAgICAgICAgICAgICBub2RlIHN0cmluZyBhcyBpdCB3YXMgaW4gdGhlIG9yaWdpbiBpbnB1dC5cbiAgICAgKlxuICAgICAqIEV2ZXJ5IHBhcnNlciBzYXZlcyBpdHMgb3duIHByb3BlcnRpZXMsXG4gICAgICogYnV0IHRoZSBkZWZhdWx0IENTUyBwYXJzZXIgdXNlczpcbiAgICAgKlxuICAgICAqICogYGJlZm9yZWA6IHRoZSBzcGFjZSBzeW1ib2xzIGJlZm9yZSB0aGUgbm9kZS5cbiAgICAgKiAqIGBsZWZ0YDogdGhlIHNwYWNlIHN5bWJvbHMgYmV0d2VlbiBgLypgIGFuZCB0aGUgY29tbWVudOKAmXMgdGV4dC5cbiAgICAgKiAqIGByaWdodGA6IHRoZSBzcGFjZSBzeW1ib2xzIGJldHdlZW4gdGhlIGNvbW1lbnTigJlzIHRleHQuXG4gICAgICovXG59XG5cbmV4cG9ydCBkZWZhdWx0IENvbW1lbnQ7XG4iXX0=

node_modules/@vue/cli-service/node_modules/postcss/lib/declaration.js

@@ -0,0 +1,101 @@
+'use strict';
+
+exports.__esModule = true;
+
+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; }
+
+/**
+ * Represents a CSS declaration.
+ *
+ * @extends Node
+ *
+ * @example
+ * const root = postcss.parse('a { color: black }');
+ * const decl = root.first.first;
+ * decl.type       //=> 'decl'
+ * decl.toString() //=> ' color: black'
+ */
+var Declaration = function (_Node) {
+  _inherits(Declaration, _Node);
+
+  function Declaration(defaults) {
+    _classCallCheck(this, Declaration);
+
+    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));
+
+    _this.type = 'decl';
+    return _this;
+  }
+
+  /**
+   * @memberof Declaration#
+   * @member {string} prop - the declaration’s property name
+   *
+   * @example
+   * const root = postcss.parse('a { color: black }');
+   * const decl = root.first.first;
+   * decl.prop //=> 'color'
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {string} value - the declaration’s value
+   *
+   * @example
+   * const root = postcss.parse('a { color: black }');
+   * const decl = root.first.first;
+   * decl.value //=> 'black'
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {boolean} important - `true` if the declaration
+   *                               has an !important annotation.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black !important; color: red }');
+   * root.first.first.important //=> true
+   * root.first.last.important  //=> undefined
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {object} raws - Information to generate byte-to-byte equal
+   *                         node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `between`: the symbols between the property and value
+   *   for declarations.
+   * * `important`: the content of the important statement,
+   *   if it is not just `!important`.
+   *
+   * PostCSS cleans declaration from comments and extra spaces,
+   * but it stores origin content in raws properties.
+   * As such, if you don’t change a declaration’s value,
+   * PostCSS will use the raw value with comments.
+   *
+   * @example
+   * const root = postcss.parse('a {\n  color:black\n}')
+   * root.first.first.raws //=> { before: '\n  ', between: ':' }
+   */
+
+  return Declaration;
+}(_node2.default);
+
+exports.default = Declaration;
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImRlY2xhcmF0aW9uLmVzNiJdLCJuYW1lcyI6WyJEZWNsYXJhdGlvbiIsImRlZmF1bHRzIiwidHlwZSIsIk5vZGUiXSwibWFwcGluZ3MiOiI7Ozs7QUFBQTs7Ozs7Ozs7Ozs7O0FBRUE7Ozs7Ozs7Ozs7O0lBV01BLFc7OztBQUVGLHVCQUFZQyxRQUFaLEVBQXNCO0FBQUE7O0FBQUEsaURBQ2xCLGlCQUFNQSxRQUFOLENBRGtCOztBQUVsQixVQUFLQyxJQUFMLEdBQVksTUFBWjtBQUZrQjtBQUdyQjs7QUFFRDs7Ozs7Ozs7OztBQVVBOzs7Ozs7Ozs7O0FBVUE7Ozs7Ozs7Ozs7O0FBV0E7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBdENzQkMsYzs7a0JBaUVYSCxXIiwiZmlsZSI6ImRlY2xhcmF0aW9uLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IE5vZGUgZnJvbSAnLi9ub2RlJztcblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgQ1NTIGRlY2xhcmF0aW9uLlxuICpcbiAqIEBleHRlbmRzIE5vZGVcbiAqXG4gKiBAZXhhbXBsZVxuICogY29uc3Qgcm9vdCA9IHBvc3Rjc3MucGFyc2UoJ2EgeyBjb2xvcjogYmxhY2sgfScpO1xuICogY29uc3QgZGVjbCA9IHJvb3QuZmlyc3QuZmlyc3Q7XG4gKiBkZWNsLnR5cGUgICAgICAgLy89PiAnZGVjbCdcbiAqIGRlY2wudG9TdHJpbmcoKSAvLz0+ICcgY29sb3I6IGJsYWNrJ1xuICovXG5jbGFzcyBEZWNsYXJhdGlvbiBleHRlbmRzIE5vZGUge1xuXG4gICAgY29uc3RydWN0b3IoZGVmYXVsdHMpIHtcbiAgICAgICAgc3VwZXIoZGVmYXVsdHMpO1xuICAgICAgICB0aGlzLnR5cGUgPSAnZGVjbCc7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQG1lbWJlcm9mIERlY2xhcmF0aW9uI1xuICAgICAqIEBtZW1iZXIge3N0cmluZ30gcHJvcCAtIHRoZSBkZWNsYXJhdGlvbuKAmXMgcHJvcGVydHkgbmFtZVxuICAgICAqXG4gICAgICogQGV4YW1wbGVcbiAgICAgKiBjb25zdCByb290ID0gcG9zdGNzcy5wYXJzZSgnYSB7IGNvbG9yOiBibGFjayB9Jyk7XG4gICAgICogY29uc3QgZGVjbCA9IHJvb3QuZmlyc3QuZmlyc3Q7XG4gICAgICogZGVjbC5wcm9wIC8vPT4gJ2NvbG9yJ1xuICAgICAqL1xuXG4gICAgLyoqXG4gICAgICogQG1lbWJlcm9mIERlY2xhcmF0aW9uI1xuICAgICAqIEBtZW1iZXIge3N0cmluZ30gdmFsdWUgLSB0aGUgZGVjbGFyYXRpb27igJlzIHZhbHVlXG4gICAgICpcbiAgICAgKiBAZXhhbXBsZVxuICAgICAqIGNvbnN0IHJvb3QgPSBwb3N0Y3NzLnBhcnNlKCdhIHsgY29sb3I6IGJsYWNrIH0nKTtcbiAgICAgKiBjb25zdCBkZWNsID0gcm9vdC5maXJzdC5maXJzdDtcbiAgICAgKiBkZWNsLnZhbHVlIC8vPT4gJ2JsYWNrJ1xuICAgICAqL1xuXG4gICAgLyoqXG4gICAgICogQG1lbWJlcm9mIERlY2xhcmF0aW9uI1xuICAgICAqIEBtZW1iZXIge2Jvb2xlYW59IGltcG9ydGFudCAtIGB0cnVlYCBpZiB0aGUgZGVjbGFyYXRpb25cbiAgICAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoYXMgYW4gIWltcG9ydGFudCBhbm5vdGF0aW9uLlxuICAgICAqXG4gICAgICogQGV4YW1wbGVcbiAgICAgKiBjb25zdCByb290ID0gcG9zdGNzcy5wYXJzZSgnYSB7IGNvbG9yOiBibGFjayAhaW1wb3J0YW50OyBjb2xvcjogcmVkIH0nKTtcbiAgICAgKiByb290LmZpcnN0LmZpcnN0LmltcG9ydGFudCAvLz0+IHRydWVcbiAgICAgKiByb290LmZpcnN0Lmxhc3QuaW1wb3J0YW50ICAvLz0+IHVuZGVmaW5lZFxuICAgICAqL1xuXG4gICAgLyoqXG4gICAgICogQG1lbWJlcm9mIERlY2xhcmF0aW9uI1xuICAgICAqIEBtZW1iZXIge29iamVjdH0gcmF3cyAtIEluZm9ybWF0aW9uIHRvIGdlbmVyYXRlIGJ5dGUtdG8tYnl0ZSBlcXVhbFxuICAgICAqICAgICAgICAgICAgICAgICAgICAgICAgIG5vZGUgc3RyaW5nIGFzIGl0IHdhcyBpbiB0aGUgb3JpZ2luIGlucHV0LlxuICAgICAqXG4gICAgICogRXZlcnkgcGFyc2VyIHNhdmVzIGl0cyBvd24gcHJvcGVydGllcyxcbiAgICAgKiBidXQgdGhlIGRlZmF1bHQgQ1NTIHBhcnNlciB1c2VzOlxuICAgICAqXG4gICAgICogKiBgYmVmb3JlYDogdGhlIHNwYWNlIHN5bWJvbHMgYmVmb3JlIHRoZSBub2RlLiBJdCBhbHNvIHN0b3JlcyBgKmBcbiAgICAgKiAgIGFuZCBgX2Agc3ltYm9scyBiZWZvcmUgdGhlIGRlY2xhcmF0aW9uIChJRSBoYWNrKS5cbiAgICAgKiAqIGBiZXR3ZWVuYDogdGhlIHN5bWJvbHMgYmV0d2VlbiB0aGUgcHJvcGVydHkgYW5kIHZhbHVlXG4gICAgICogICBmb3IgZGVjbGFyYXRpb25zLlxuICAgICAqICogYGltcG9ydGFudGA6IHRoZSBjb250ZW50IG9mIHRoZSBpbXBvcnRhbnQgc3RhdGVtZW50LFxuICAgICAqICAgaWYgaXQgaXMgbm90IGp1c3QgYCFpbXBvcnRhbnRgLlxuICAgICAqXG4gICAgICogUG9zdENTUyBjbGVhbnMgZGVjbGFyYXRpb24gZnJvbSBjb21tZW50cyBhbmQgZXh0cmEgc3BhY2VzLFxuICAgICAqIGJ1dCBpdCBzdG9yZXMgb3JpZ2luIGNvbnRlbnQgaW4gcmF3cyBwcm9wZXJ0aWVzLlxuICAgICAqIEFzIHN1Y2gsIGlmIHlvdSBkb27igJl0IGNoYW5nZSBhIGRlY2xhcmF0aW9u4oCZcyB2YWx1ZSxcbiAgICAgKiBQb3N0Q1NTIHdpbGwgdXNlIHRoZSByYXcgdmFsdWUgd2l0aCBjb21tZW50cy5cbiAgICAgKlxuICAgICAqIEBleGFtcGxlXG4gICAgICogY29uc3Qgcm9vdCA9IHBvc3Rjc3MucGFyc2UoJ2Ege1xcbiAgY29sb3I6YmxhY2tcXG59JylcbiAgICAgKiByb290LmZpcnN0LmZpcnN0LnJhd3MgLy89PiB7IGJlZm9yZTogJ1xcbiAgJywgYmV0d2VlbjogJzonIH1cbiAgICAgKi9cblxufVxuXG5leHBvcnQgZGVmYXVsdCBEZWNsYXJhdGlvbjtcbiJdfQ==