first commit

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

@@ -0,0 +1,212 @@
+const path = require('path')
+const hash = require('hash-sum')
+const { semver, 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
+  }
+
+  get version () {
+    return require('../package.json').version
+  }
+
+  assertVersion (range) {
+    if (typeof range === 'number') {
+      if (!Number.isInteger(range)) {
+        throw new Error('Expected string or integer value.')
+      }
+      range = `^${range}.0.0-0`
+    }
+    if (typeof range !== 'string') {
+      throw new Error('Expected string or integer value.')
+    }
+
+    if (semver.satisfies(this.version, range, { includePrerelease: true })) return
+
+    throw new Error(
+      `Require @vue/cli-service "${range}", but was loaded with "${this.version}".`
+    )
+  }
+
+  /**
+   * 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) {
+    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 (!Array.isArray(configFiles)) {
+      configFiles = [configFiles]
+    }
+    configFiles = configFiles.concat([
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml'
+    ])
+
+    const readConfig = file => {
+      const absolutePath = this.resolve(file)
+      if (!fs.existsSync(absolutePath)) {
+        return
+      }
+
+      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')
+      }
+    }
+
+    variables.configFiles = configFiles.map(file => {
+      const content = readConfig(file)
+      return content && content.replace(/\r\n?/g, '\n')
+    })
+
+    const cacheIdentifier = hash(variables)
+    return { cacheDirectory, cacheIdentifier }
+  }
+}
+
+module.exports = PluginAPI

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

@@ -0,0 +1,438 @@
+const fs = require('fs')
+const path = require('path')
+const debug = require('debug')
+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 { chalk, warn, error, isPlugin, resolvePluginId, loadModule, resolvePkg } = 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)
+    // pluginsToSkip will be populated during run()
+    this.pluginsToSkip = new Set()
+    // 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
+    }
+    const pkg = resolvePkg(context)
+    if (pkg.vuePlugins && pkg.vuePlugins.resolveFrom) {
+      this.pkgContext = path.resolve(context, pkg.vuePlugins.resolveFrom)
+      return this.resolvePkg(null, this.pkgContext)
+    }
+    return pkg
+  }
+
+  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 }) => {
+      if (this.pluginsToSkip.has(id)) return
+      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 = envPath => {
+      try {
+        const env = dotenv.config({ path: envPath, debug: process.env.DEBUG })
+        dotenvExpand(env)
+        logger(envPath, 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
+      }
+    }
+  }
+
+  setPluginsToSkip (args) {
+    const skipPlugins = args['skip-plugins']
+    const pluginsToSkip = skipPlugins
+      ? new Set(skipPlugins.split(',').map(id => resolvePluginId(id)))
+      : new Set()
+
+    this.pluginsToSkip = pluginsToSkip
+  }
+
+  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/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])
+
+    // --skip-plugins arg may have plugins that should be skipped during init()
+    this.setPluginsToSkip(args)
+
+    // 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 (
+      !process.env.VUE_CLI_ENTRY_FILES &&
+      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.c?js
+    let fileConfig, pkgConfig, resolved, resolvedFrom
+    const esm = this.pkg.type && this.pkg.type === 'module'
+
+    const possibleConfigPaths = [
+      process.env.VUE_CLI_SERVICE_CONFIG_PATH,
+      './vue.config.js',
+      './vue.config.cjs'
+    ]
+
+    let fileConfigPath
+    for (const p of possibleConfigPaths) {
+      const resolvedPath = p && path.resolve(this.context, p)
+      if (resolvedPath && fs.existsSync(resolvedPath)) {
+        fileConfigPath = resolvedPath
+        break
+      }
+    }
+
+    if (fileConfigPath) {
+      if (esm && fileConfigPath === './vue.config.js') {
+        throw new Error(`Please rename ${chalk.bold('vue.config.js')} to ${chalk.bold('vue.config.cjs')} when ECMAScript modules is enabled`)
+      }
+
+      try {
+        fileConfig = loadModule(fileConfigPath, this.context)
+
+        if (typeof fileConfig === 'function') {
+          fileConfig = fileConfig()
+        }
+
+        if (!fileConfig || typeof fileConfig !== 'object') {
+          // TODO: show throw an Error here, to be fixed in v5
+          error(
+            `Error loading ${chalk.bold(fileConfigPath)}: should export an object or a function that returns object.`
+          )
+          fileConfig = null
+        }
+      } catch (e) {
+        error(`Error loading ${chalk.bold(fileConfigPath)}:`)
+        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 (resolved.css && typeof resolved.css.modules !== 'undefined') {
+      if (typeof resolved.css.requireModuleExtension !== 'undefined') {
+        warn(
+          `You have set both "css.modules" and "css.requireModuleExtension" in ${chalk.bold('vue.config.js')}, ` +
+          `"css.modules" will be ignored in favor of "css.requireModuleExtension".`
+        )
+      } else {
+        warn(
+          `"css.modules" option in ${chalk.bold('vue.config.js')} ` +
+          `is deprecated now, please use "css.requireModuleExtension" instead.`
+        )
+        resolved.css.requireModuleExtension = !resolved.css.modules
+      }
+    }
+
+    // normalize some options
+    ensureSlash(resolved, 'publicPath')
+    if (typeof resolved.publicPath === 'string') {
+      resolved.publicPath = resolved.publicPath.replace(/^\.\//, '')
+    }
+    removeSlash(resolved, 'outputDir')
+
+    // validate options
+    validate(resolved, msg => {
+      error(
+        `Invalid options in ${chalk.bold(resolvedFrom)}: ${msg}`
+      )
+    })
+
+    return resolved
+  }
+}
+
+function ensureSlash (config, key) {
+  const val = config[key]
+  if (typeof val === 'string') {
+    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.assetsFileName %>.umd.js"></script>
+<% if (htmlWebpackPlugin.options.cssExtract) { %>
+<link rel="stylesheet" href="./<%- htmlWebpackPlugin.options.assetsFileName %>.css">
+<% } %>
+
+<script>
+console.log(<%- htmlWebpackPlugin.options.libName %>)
+</script>

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

@@ -0,0 +1,27 @@
+<meta charset="utf-8">
+<title><%- htmlWebpackPlugin.options.libName %> demo</title>
+<script src="//unpkg.com/vue@<%- htmlWebpackPlugin.options.vueMajor %>"></script>
+<script src="./<%- htmlWebpackPlugin.options.assetsFileName %>.umd.js"></script>
+<% if (htmlWebpackPlugin.options.cssExtract) { %>
+<link rel="stylesheet" href="./<%- htmlWebpackPlugin.options.assetsFileName %>.css">
+<% } %>
+
+<div id="app">
+  <demo></demo>
+</div>
+
+<script>
+<% if (htmlWebpackPlugin.options.vueMajor === 3) { %>
+Vue.createApp({
+  components: {
+    demo: <%- htmlWebpackPlugin.options.libName %>
+  }
+}).mount('#app')
+<% } else { %>
+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@<%- htmlWebpackPlugin.options.vueMajor %>"></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,72 @@
+module.exports = function formatStats (stats, dir, api) {
+  const fs = require('fs')
+  const path = require('path')
+  const zlib = require('zlib')
+  const ui = require('cliui')({ width: process.stdout.columns || 80 })
+  const { chalk } = require('@vue/cli-shared-utils')
+
+  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
+    .map(a => {
+      a.name = a.name.split('?')[0]
+      return a
+    })
+    .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,238 @@
+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})`,
+      '--inline-vue': 'include the Vue module in the final bundle of library or web component 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)`,
+      '--filename': `file name for output, only usable for 'lib' target (default: value of --name)`,
+      '--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',
+      '--skip-plugins': `comma-separated list of plugin names to skip for this run`,
+      '--watch': `watch for changes`,
+      '--stdin': `close when stdin ends`
+    }
+  }, 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('node', [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 webpack = require('webpack')
+  const { chalk } = require('@vue/cli-shared-utils')
+  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}`)
+    }
+  }
+
+  if (args.dest) {
+    // Override outputDir before resolving webpack config as config relies on it (#2327)
+    options.outputDir = args.dest
+  }
+
+  const targetDir = api.resolve(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)
+
+  if (args.watch) {
+    modifyConfig(webpackConfig, config => {
+      config.watch = true
+    })
+  }
+
+  if (args.stdin) {
+    process.stdin.on('end', () => {
+      process.exit(0)
+    })
+    process.stdin.resume()
+  }
+
+  // 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) => {
+  // respect inline entry
+  if (args.entry && !options.pages) {
+    api.configureWebpack(config => {
+      config.entry = { app: api.resolve(args.entry) }
+    })
+  }
+
+  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(pluginArgs => {
+      pluginArgs[0][0].to = targetDir
+      return pluginArgs
+    })
+  }
+
+  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')
+        }])
+    }
+  }
+
+  return api.resolveWebpackConfig(config)
+}

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

@@ -0,0 +1,154 @@
+const fs = require('fs')
+const path = require('path')
+
+module.exports = (api, { entry, name, formats, filename, 'inline-vue': inlineVue }, options) => {
+  const { log, error } = require('@vue/cli-shared-utils')
+  const abort = msg => {
+    log()
+    error(msg)
+    process.exit(1)
+  }
+
+  const vueMajor = require('../../util/getVueMajor')(api.getCwd())
+
+  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
+        ? api.service.pkg.name.replace(/^@.+\//, '')
+        : path.basename(entry).replace(/\.(jsx?|vue)$/, '')
+    )
+  )
+  filename = filename || libName
+  function genConfig (format, postfix = format, genHTML) {
+    const config = api.resolveChainableWebpackConfig()
+
+    const browserslist = require('browserslist')
+    const targets = browserslist(undefined, { path: fullEntryPath })
+    const supportsIE = targets.some(agent => agent.includes('ie'))
+
+    const webpack = require('webpack')
+    config.plugin('need-current-script-polyfill')
+      .use(webpack.DefinePlugin, [{
+        'process.env.NEED_CURRENTSCRIPT_POLYFILL': JSON.stringify(supportsIE)
+      }])
+
+    // 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 = `${filename}.css`
+            return args
+          })
+    }
+
+    // only minify min entry
+    if (!/\.min/.test(postfix)) {
+      config.optimization.minimize(false)
+    }
+
+    // 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,
+            vueMajor,
+            assetsFileName: filename,
+            cssExtract: config.plugins.has('extract-css')
+          }])
+    }
+
+    // resolve entry/output
+    const entryName = `${filename}.${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')
+      }
+    }
+
+    // externalize Vue in case user imports it
+    rawConfig.externals = [
+      ...(Array.isArray(rawConfig.externals) ? rawConfig.externals : [rawConfig.externals]),
+      {
+        ...(inlineVue || {
+          vue: {
+            commonjs: 'vue',
+            commonjs2: 'vue',
+            root: 'Vue'
+          }
+        })
+      }
+    ].filter(Boolean)
+
+    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,135 @@
+const path = require('path')
+const { resolveEntry, fileToComponentName } = require('./resolveWcEntry')
+
+module.exports = (api, { target, entry, name, 'inline-vue': inlineVue }) => {
+  // 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 cwd = api.getCwd()
+  const vueMajor = require('../../util/getVueMajor')(cwd)
+  if (vueMajor === 3) {
+    abort(`Vue 3 support of the web component target is still under development.`)
+  }
+
+  const isAsync = /async/.test(target)
+
+  // generate dynamic entry based on glob files
+  const resolvedFiles = require('globby').sync(entry.split(','), { 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)
+    }
+
+    config
+      .plugin('web-component-options')
+        .use(require('webpack').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,
+            vueMajor,
+            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)
+
+    // externalize Vue in case user imports it
+    rawConfig.externals = [
+      ...(Array.isArray(rawConfig.externals) ? rawConfig.externals : [rawConfig.externals]),
+      { ...(inlineVue || { vue: 'Vue' }) }
+    ].filter(Boolean)
+
+    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} isAsync Whether to load component async or not
+ */
+const createElement = (prefix, component, file, isAsync) => {
+  const { camelName, kebabName } = exports.fileToComponentName(prefix, component)
+
+  return isAsync
+    ? `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, isAsync) => {
+  const filePath = path.resolve(__dirname, 'entry-wc.js')
+  const elements =
+    prefix === ''
+      ? [createElement('', libName, files[0])]
+      : files.map(file => createElement(prefix, file, file, isAsync)).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/dist/runtime/api.js'
+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,22 @@
+// This file is imported into lib/wc client bundles.
+
+if (typeof window !== 'undefined') {
+  var currentScript = window.document.currentScript
+  if (process.env.NEED_CURRENTSCRIPT_POLYFILL) {
+    var getCurrentScript = require('@soda/get-current-script')
+    currentScript = getCurrentScript()
+
+    // for backward compatibility, because previously we directly included the polyfill
+    if (!('currentScript' in document)) {
+      Object.defineProperty(document, 'currentScript', { get: getCurrentScript })
+    }
+  }
+
+  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
+  if (src) {
+    __webpack_public_path__ = src[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,62 @@
+const { chalk } = require('@vue/cli-shared-utils')
+const getPadLength = require('../util/getPadLength')
+
+module.exports = (api, options) => {
+  api.registerCommand('help', args => {
+    const commandName = args._[0]
+    if (!commandName) {
+      logMainHelp()
+    } else {
+      logHelpForCommand(commandName, api.service.commands[commandName])
+    }
+  })
+
+  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(name.padEnd(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 [flags, description] of Object.entries(opts.options)) {
+          console.log(`    ${
+            chalk.blue(flags.padEnd(padLength))
+          }${
+            description
+          }`)
+        }
+      }
+      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,74 @@
+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',
+        '--skip-plugins': 'comma-separated list of plugin names to skip for this run'
+      }
+    },
+    args => {
+      const { chalk, get } = require('@vue/cli-shared-utils')
+      const { toString } = require('webpack-chain')
+      const { highlight } = require('cli-highlight')
+      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(highlight(output, { language: 'js' }))
+
+      // 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,377 @@
+const {
+  info,
+  error,
+  hasProjectYarn,
+  hasProjectPnpm,
+  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`,
+      '--stdin': `close when stdin ends`,
+      '--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`,
+      '--skip-plugins': `comma-separated list of plugin names to skip for this run`
+    }
+  }, 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('@vue/cli-shared-utils')
+    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')
+
+    // configs that only matters for dev server
+    api.chainWebpack(webpackConfig => {
+      if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
+        webpackConfig
+          .devtool('eval-cheap-module-source-map')
+
+        webpackConfig
+          .plugin('hmr')
+            .use(require('webpack/lib/HotModuleReplacementPlugin'))
+
+        // https://github.com/webpack/webpack/issues/6642
+        // https://github.com/vuejs/vue-cli/issues/3539
+        webpackConfig
+          .output
+            .globalObject(`(typeof self !== 'undefined' ? self : this)`)
+
+        if (!process.env.VUE_CLI_TEST && options.devServer.progress !== false) {
+          webpackConfig
+            .plugin('progress')
+            .use(require('webpack/lib/ProgressPlugin'))
+        }
+      }
+    })
+
+    // 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 webpack 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 localUrlForBrowser = publicUrl || urls.localUrlForBrowser
+
+    const proxySettings = prepareProxy(
+      projectDevServerOptions.proxy,
+      api.resolve('public')
+    )
+
+    // inject dev & hot-reload middleware entries
+    if (!isProduction) {
+      const sockPath = projectDevServerOptions.sockPath || '/sockjs-node'
+      const sockjsUrl = publicUrl
+        // explicitly configured via devServer.public
+        ? `?${publicUrl}&sockPath=${sockPath}`
+        : isInContainer
+          // can't infer public network 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'
+          }) + `&sockPath=${sockPath}`
+      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)
+
+    // handle compiler error
+    compiler.hooks.failed.tap('vue-cli-service serve', msg => {
+      error(msg)
+      process.exit(1)
+    })
+
+    // create server
+    const server = new WebpackDevServer(compiler, Object.assign({
+      logLevel: 'silent',
+      clientLogLevel: 'silent',
+      historyApiFallback: {
+        disableDotRule: true,
+        rewrites: genHistoryApiFallbackRewrites(options.publicPath, options.pages)
+      },
+      contentBase: api.resolve('public'),
+      watchContentBase: !isProduction,
+      hot: !isProduction,
+      injectClient: false,
+      compress: isProduction,
+      publicPath: options.publicPath,
+      overlay: isProduction // TODO disable this
+        ? false
+        : { warnings: false, errors: true }
+    }, projectDevServerOptions, {
+      https: useHttps,
+      proxy: proxySettings,
+      // eslint-disable-next-line no-shadow
+      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, specify 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)
+      },
+      // avoid opening browser
+      open: false
+    }))
+
+    ;['SIGINT', 'SIGTERM'].forEach(signal => {
+      process.on(signal, () => {
+        server.close(() => {
+          process.exit(0)
+        })
+      })
+    })
+
+    if (args.stdin) {
+      process.stdin.on('end', () => {
+        server.close(() => {
+          process.exit(0)
+        })
+      })
+
+      process.stdin.resume()
+    }
+
+    // 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(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` : hasProjectPnpm(api.getCwd()) ? `pnpm run 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(localUrlForBrowser + pageUri)
+          }
+
+          // Send final app URL
+          if (args.dashboard) {
+            const ipc = new IpcMessenger()
+            ipc.send({
+              vueServe: {
+                url: localUrlForBrowser
+              }
+            })
+          }
+
+          // resolve returned Promise
+          // so other commands can do api.service.run('serve').then(...)
+          resolve({
+            server,
+            url: 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 () {
+  if ('CODESANDBOX_SSE' in process.env) {
+    return true
+  }
+  const fs = require('fs')
+  if (fs.existsSync(`/proc/1/cgroup`)) {
+    const content = fs.readFileSync(`/proc/1/cgroup`, 'utf-8')
+    return /:\/(lxc|docker|kubepods(\.slice)?)\//.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,306 @@
+// 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)
+
+    const getAssetPath = require('../util/getAssetPath')
+    const outputFilename = getAssetPath(
+      options,
+      `js/[name]${isLegacyBundle ? `-legacy` : ``}${isProd && options.filenameHashing ? '.[contenthash:8]' : ''}.js`
+    )
+    webpackConfig
+      .output
+        .filename(outputFilename)
+        .chunkFilename(outputFilename)
+
+    // code splitting
+    if (process.env.NODE_ENV !== 'test') {
+      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 = {
+      title: api.service.pkg.name,
+      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 */))
+      }
+    }
+
+    // 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)
+        ])
+    }
+
+    if (isProd) {
+      Object.assign(htmlOptions, {
+        minify: {
+          removeComments: true,
+          collapseWhitespace: 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
+
+      publicCopyIgnore.push({
+        glob: path.relative(api.resolve('public'), api.resolve(htmlOptions.template)),
+        matchBase: false
+      })
+
+      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
+        const entries = Array.isArray(entry) ? entry : [entry]
+        webpackConfig.entry(name).merge(entries.map(e => api.resolve(e)))
+
+        // resolve page index template
+        const hasDedicatedTemplate = fs.existsSync(api.resolve(template))
+        const templatePath = hasDedicatedTemplate
+          ? template
+          : fs.existsSync(htmlPath)
+            ? htmlPath
+            : defaultHtmlPath
+
+        publicCopyIgnore.push({
+          glob: path.relative(api.resolve('public'), api.resolve(templatePath)),
+          matchBase: false
+        })
+
+        // 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,279 @@
+const { semver, loadModule } = require('@vue/cli-shared-utils')
+
+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: require.resolve('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
+      // This plugin can be removed once we switch to Webpack 6
+      .plugin('pnp')
+        .use({ ...require('pnp-webpack-plugin') })
+        .end()
+      .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'))
+
+    webpackConfig.resolveLoader
+      .plugin('pnp-loaders')
+        .use({ ...require('pnp-webpack-plugin').topLevelLoader })
+        .end()
+      .modules
+        .add('node_modules')
+        .add(api.resolve('node_modules'))
+        .add(resolveLocal('node_modules'))
+
+    webpackConfig.module
+      .noParse(/^(vue|vue-router|vuex|vuex-router-sync)$/)
+
+    webpackConfig.module
+      .rule('mjs')
+        .test(/\.mjs$/)
+        .include
+          .add(/node_modules/)
+          .end()
+        .type('javascript/auto')
+
+    // js is handled by cli-plugin-babel ---------------------------------------
+
+    // vue-loader --------------------------------------------------------------
+    // try to load vue in the project
+    // fallback to peer vue package in the instant prototyping environment
+    const vue = loadModule('vue', api.service.context) || loadModule('vue', __dirname)
+
+    if (vue && semver.major(vue.version) === 2) {
+      // for Vue 2 projects
+      const partialIdentifier = {
+        'vue-loader': require('vue-loader/package.json').version,
+        '@vue/component-compiler-utils': require('@vue/component-compiler-utils/package.json').version
+      }
+
+      try {
+        partialIdentifier['vue-template-compiler'] = require('vue-template-compiler/package.json').version
+      } catch (e) {
+        // For Vue 2.7 projects, `vue-template-compiler` is not required
+      }
+
+      const vueLoaderCacheConfig = api.genCacheConfig('vue-loader', partialIdentifier)
+
+      webpackConfig.resolve
+        .alias
+          .set(
+            'vue$',
+            options.runtimeCompiler
+              ? 'vue/dist/vue.esm.js'
+              : 'vue/dist/vue.runtime.esm.js'
+          )
+
+      webpackConfig.module
+        .rule('vue')
+          .test(/\.vue$/)
+          .use('cache-loader')
+            .loader(require.resolve('cache-loader'))
+            .options(vueLoaderCacheConfig)
+            .end()
+          .use('vue-loader')
+            .loader(require.resolve('vue-loader'))
+            .options(Object.assign({
+              compilerOptions: {
+                whitespace: 'condense'
+              }
+            }, vueLoaderCacheConfig))
+
+      webpackConfig
+        .plugin('vue-loader')
+          .use(require('vue-loader').VueLoaderPlugin)
+    } else if (vue && semver.major(vue.version) === 3) {
+      // for Vue 3 projects
+      const vueLoaderCacheConfig = api.genCacheConfig('vue-loader', {
+        'vue-loader': require('vue-loader-v16/package.json').version,
+        '@vue/compiler-sfc': require('@vue/compiler-sfc/package.json').version
+      })
+
+      webpackConfig.resolve
+        .alias
+          .set(
+            'vue$',
+            options.runtimeCompiler
+              ? 'vue/dist/vue.esm-bundler.js'
+              : 'vue/dist/vue.runtime.esm-bundler.js'
+          )
+
+      webpackConfig.module
+        .rule('vue')
+          .test(/\.vue$/)
+          .use('cache-loader')
+            .loader(require.resolve('cache-loader'))
+            .options(vueLoaderCacheConfig)
+            .end()
+          .use('vue-loader')
+            .loader(require.resolve('vue-loader-v16'))
+            .options({
+              ...vueLoaderCacheConfig,
+              babelParserPlugins: ['jsx', 'classProperties', 'decorators-legacy']
+            })
+            .end()
+          .end()
+
+      webpackConfig
+        .plugin('vue-loader')
+          .use(require('vue-loader-v16').VueLoaderPlugin)
+
+      // feature flags <http://link.vuejs.org/feature-flags>
+      webpackConfig
+        .plugin('feature-flags')
+          .use(require('webpack').DefinePlugin, [{
+            __VUE_OPTIONS_API__: 'true',
+            __VUE_PROD_DEVTOOLS__: 'false'
+          }])
+    }
+
+    // static assets -----------------------------------------------------------
+
+    webpackConfig.module
+      .rule('images')
+        .test(/\.(png|jpe?g|gif|webp)(\?.*)?$/)
+        .use('url-loader')
+          .loader(require.resolve('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(require.resolve('file-loader'))
+          .options({
+            name: genAssetSubPath('img')
+          })
+
+    webpackConfig.module
+      .rule('media')
+        .test(/\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/)
+        .use('url-loader')
+          .loader(require.resolve('url-loader'))
+          .options(genUrlLoaderOptions('media'))
+
+    webpackConfig.module
+      .rule('fonts')
+        .test(/\.(woff2?|eot|ttf|otf)(\?.*)?$/i)
+        .use('url-loader')
+          .loader(require.resolve('url-loader'))
+          .options(genUrlLoaderOptions('fonts'))
+
+    // Other common pre-processors ---------------------------------------------
+
+    const maybeResolve = name => {
+      try {
+        return require.resolve(name)
+      } catch (error) {
+        return name
+      }
+    }
+
+    webpackConfig.module
+      .rule('pug')
+        .test(/\.pug$/)
+          .oneOf('pug-vue')
+            .resourceQuery(/vue/)
+            .use('pug-plain-loader')
+              .loader(maybeResolve('pug-plain-loader'))
+              .end()
+            .end()
+          .oneOf('pug-template')
+            .use('raw')
+              .loader(maybeResolve('raw-loader'))
+              .end()
+            .use('pug-plain-loader')
+              .loader(maybeResolve('pug-plain-loader'))
+              .end()
+            .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').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]
+        }])
+
+    const TerserPlugin = require('terser-webpack-plugin')
+    const terserOptions = require('./terserOptions')
+    webpackConfig.optimization
+      .minimizer('terser')
+        .use(TerserPlugin, [terserOptions(options)])
+  })
+}

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

@@ -0,0 +1,253 @@
+const fs = require('fs')
+const path = require('path')
+const { semver, warn, pauseSpinner, resumeSpinner } = require('@vue/cli-shared-utils')
+
+const findExisting = (context, files) => {
+  for (const file of files) {
+    if (fs.existsSync(path.join(context, file))) {
+      return file
+    }
+  }
+}
+
+module.exports = (api, rootOptions) => {
+  api.chainWebpack(webpackConfig => {
+    const getAssetPath = require('../util/getAssetPath')
+    const shadowMode = !!process.env.VUE_CLI_CSS_SHADOW_MODE
+    const isProd = process.env.NODE_ENV === 'production'
+
+    let sassLoaderVersion
+    try {
+      sassLoaderVersion = semver.major(require('sass-loader/package.json').version)
+    } catch (e) {}
+    if (sassLoaderVersion < 8) {
+      pauseSpinner()
+      warn('A new version of sass-loader is available. Please upgrade for best experience.')
+      resumeSpinner()
+    }
+
+    const defaultSassLoaderOptions = {}
+    try {
+      defaultSassLoaderOptions.implementation = require('sass')
+      // since sass-loader 8, fibers will be automatically detected and used
+      if (sassLoaderVersion < 8) {
+        defaultSassLoaderOptions.fiber = require('fibers')
+      }
+    } catch (e) {}
+
+    const {
+      extract = isProd,
+      sourceMap = false,
+      loaderOptions = {}
+    } = rootOptions.css || {}
+
+    let { requireModuleExtension } = rootOptions.css || {}
+    if (typeof requireModuleExtension === 'undefined') {
+      if (loaderOptions.css && loaderOptions.css.modules) {
+        throw new Error('`css.requireModuleExtension` is required when custom css modules options provided')
+      }
+      requireModuleExtension = true
+    }
+
+    const shouldExtract = extract !== false && !shadowMode
+    const filename = getAssetPath(
+      rootOptions,
+      `css/[name]${rootOptions.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 (!hasPostCSSConfig) {
+      loaderOptions.postcss = {
+        plugins: [
+          require('autoprefixer')
+        ]
+      }
+    }
+
+    // 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 (rootOptions.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, !requireModuleExtension)
+
+      function applyLoaders (rule, isCssModule) {
+        if (shouldExtract) {
+          rule
+            .use('extract-css-loader')
+            .loader(require('mini-css-extract-plugin').loader)
+            .options({
+              hmr: !isProd,
+              publicPath: cssPublicPath
+            })
+        } else {
+          rule
+            .use('vue-style-loader')
+            .loader(require.resolve('vue-style-loader'))
+            .options({
+              sourceMap,
+              shadowMode
+            })
+        }
+
+        const cssLoaderOptions = Object.assign({
+          sourceMap,
+          importLoaders: (
+            1 + // stylePostLoader injected by vue-loader
+            1 + // postcss-loader
+            (needInlineMinification ? 1 : 0)
+          )
+        }, loaderOptions.css)
+
+        if (isCssModule) {
+          cssLoaderOptions.modules = {
+            localIdentName: '[name]_[local]_[hash:base64:5]',
+            ...cssLoaderOptions.modules
+          }
+        } else {
+          delete cssLoaderOptions.modules
+        }
+
+        rule
+          .use('css-loader')
+          .loader(require.resolve('css-loader'))
+          .options(cssLoaderOptions)
+
+        if (needInlineMinification) {
+          rule
+            .use('cssnano')
+            .loader(require.resolve('postcss-loader'))
+            .options({
+              sourceMap,
+              plugins: [require('cssnano')(cssnanoOptions)]
+            })
+        }
+
+        rule
+          .use('postcss-loader')
+          .loader(require.resolve('postcss-loader'))
+          .options(Object.assign({ sourceMap }, loaderOptions.postcss))
+
+        if (loader) {
+          let resolvedLoader
+          try {
+            resolvedLoader = require.resolve(loader)
+          } catch (error) {
+            resolvedLoader = loader
+          }
+
+          rule
+            .use(loader)
+            .loader(resolvedLoader)
+            .options(Object.assign({ sourceMap }, options))
+        }
+      }
+    }
+
+    createCSSRule('css', /\.css$/)
+    createCSSRule('postcss', /\.p(ost)?css$/)
+    createCSSRule('scss', /\.scss$/, 'sass-loader', Object.assign(
+      {},
+      defaultSassLoaderOptions,
+      loaderOptions.scss || loaderOptions.sass
+    ))
+    if (sassLoaderVersion < 8) {
+      createCSSRule('sass', /\.sass$/, 'sass-loader', Object.assign(
+        {},
+        defaultSassLoaderOptions,
+        {
+          indentedSyntax: true
+        },
+        loaderOptions.sass
+      ))
+    } else {
+      createCSSRule('sass', /\.sass$/, 'sass-loader', Object.assign(
+        {},
+        defaultSassLoaderOptions,
+        loaderOptions.sass,
+        {
+          sassOptions: Object.assign(
+            {},
+            loaderOptions.sass && loaderOptions.sass.sassOptions,
+            {
+              indentedSyntax: true
+            }
+          )
+        }
+      ))
+    }
+    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: rootOptions.productionSourceMap && sourceMap,
+              cssnanoOptions
+            }])
+      }
+    }
+  })
+}

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

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="">
+  <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,21 @@
+module.exports = (api, options) => {
+  api.chainWebpack(webpackConfig => {
+    if (process.env.NODE_ENV === 'production') {
+      webpackConfig
+        .mode('production')
+        .devtool(options.productionSourceMap ? 'source-map' : false)
+
+      // 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)
+      }
+    }
+  })
+}

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

@@ -0,0 +1,42 @@
+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 noticeable 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,
+  extractComments: false
+})

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

@@ -0,0 +1,143 @@
+const { createSchema, validate } = require('@vue/cli-shared-utils')
+
+const schema = createSchema(joi => joi.object({
+  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.alternatives().try([
+    joi.boolean(),
+    joi.number().integer()
+  ]),
+  devServer: joi.object(),
+  pages: joi.object().pattern(
+    /\w+/,
+    joi.alternatives().try([
+      joi.string().required(),
+      joi.array().items(joi.string().required()),
+
+      joi.object().keys({
+        entry: joi.alternatives().try([
+          joi.string().required(),
+          joi.array().items(joi.string().required())
+        ]).required()
+      }).unknown(true)
+    ])
+  ),
+  crossorigin: joi.string().valid(['', 'anonymous', 'use-credentials']),
+  integrity: joi.boolean(),
+
+  // css
+  css: joi.object({
+    // TODO: deprecate this after joi 16 release
+    modules: joi.boolean(),
+    requireModuleExtension: joi.boolean(),
+    extract: joi.alternatives().try(joi.boolean(), joi.object()),
+    sourceMap: joi.boolean(),
+    loaderOptions: joi.object({
+      css: joi.object(),
+      sass: joi.object(),
+      scss: 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', 'warning', 'default']),
+  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: '/',
+
+  // 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,
+    // sourceMap: false,
+    // loaderOptions: {}
+  },
+
+  // whether to use eslint-loader
+  lintOnSave: 'default',
+
+  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) {
+  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/getVueMajor.js

@@ -0,0 +1,13 @@
+const { semver, loadModule } = require('@vue/cli-shared-utils')
+
+/**
+ * Get the major Vue version that the user project uses
+ * @param {string} cwd the user project root
+ * @returns {2|3}
+ */
+module.exports = function getVueMajor (cwd) {
+  const vue = loadModule('vue', cwd)
+  // TODO: make Vue 3 the default version
+  const vueMajor = vue ? semver.major(vue.version) : 2
+  return vueMajor
+}

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,205 @@
+/**
+ * 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('@vue/cli-shared-utils')
+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)
+  }
+
+  // If proxy is specified, let it handle any request except for
+  // files in the public folder and requests to the WebpackDevServer socket endpoint.
+  // https://github.com/facebook/create-react-app/issues/6720
+  function mayProxy (pathname) {
+    const maybePublicPath = path.resolve(appPublicFolder, pathname.slice(1))
+    const isPublicFileRequest = fs.existsSync(maybePublicPath) && fs.statSync(maybePublicPath).isFile()
+    const isWdsEndpointRequest = pathname.startsWith('/sockjs-node') // used by webpackHotDevClient
+    return !(isPublicFileRequest || isWdsEndpointRequest)
+  }
+
+  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,70 @@
+/**
+ * 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('@vue/cli-shared-utils')
+const address = require('address')
+const defaultGateway = require('default-gateway')
+
+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
+      const result = defaultGateway.v4.sync()
+      lanUrlForConfig = address.ip(result && result.interface)
+      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('@vue/cli-shared-utils')
+
+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 default 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(prop => prop.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 }
+}