no message

README.md

@@ -1,21 +0,0 @@
-# schrepair
-
-> A Vue.js project
-
-## Build Setup
-
-``` bash
-# install dependencies
-npm install
-
-# serve with hot reload at localhost:8080
-npm run dev
-
-# build for production with minification
-npm run build
-
-# build for production and view the bundle analyzer report
-npm run build --report
-```
-
-For a detailed explanation on how things work, check out the [guide](http://vuejs-templates.github.io/webpack/) and [docs for vue-loader](http://vuejs.github.io/vue-loader).

build/build.js

@@ -1,41 +0,0 @@
-'use strict'
-require('./check-versions')()
-
-process.env.NODE_ENV = 'production'
-
-const ora = require('ora')
-const rm = require('rimraf')
-const path = require('path')
-const chalk = require('chalk')
-const webpack = require('webpack')
-const config = require('../config')
-const webpackConfig = require('./webpack.prod.conf')
-
-const spinner = ora('building for production...')
-spinner.start()
-
-rm(path.join(config.build.assetsRoot, config.build.assetsSubDirectory), err => {
-  if (err) throw err
-  webpack(webpackConfig, (err, stats) => {
-    spinner.stop()
-    if (err) throw err
-    process.stdout.write(stats.toString({
-      colors: true,
-      modules: false,
-      children: false, // If you are using ts-loader, setting this to true will make TypeScript errors show up during build.
-      chunks: false,
-      chunkModules: false
-    }) + '\n\n')
-
-    if (stats.hasErrors()) {
-      console.log(chalk.red('  Build failed with errors.\n'))
-      process.exit(1)
-    }
-
-    console.log(chalk.cyan('  Build complete.\n'))
-    console.log(chalk.yellow(
-      '  Tip: built files are meant to be served over an HTTP server.\n' +
-      '  Opening index.html over file:// won\'t work.\n'
-    ))
-  })
-})

build/check-versions.js

@@ -1,54 +0,0 @@
-'use strict'
-const chalk = require('chalk')
-const semver = require('semver')
-const packageConfig = require('../package.json')
-const shell = require('shelljs')
-
-function exec (cmd) {
-  return require('child_process').execSync(cmd).toString().trim()
-}
-
-const versionRequirements = [
-  {
-    name: 'node',
-    currentVersion: semver.clean(process.version),
-    versionRequirement: packageConfig.engines.node
-  }
-]
-
-if (shell.which('npm')) {
-  versionRequirements.push({
-    name: 'npm',
-    currentVersion: exec('npm --version'),
-    versionRequirement: packageConfig.engines.npm
-  })
-}
-
-module.exports = function () {
-  const warnings = []
-
-  for (let i = 0; i < versionRequirements.length; i++) {
-    const mod = versionRequirements[i]
-
-    if (!semver.satisfies(mod.currentVersion, mod.versionRequirement)) {
-      warnings.push(mod.name + ': ' +
-        chalk.red(mod.currentVersion) + ' should be ' +
-        chalk.green(mod.versionRequirement)
-      )
-    }
-  }
-
-  if (warnings.length) {
-    console.log('')
-    console.log(chalk.yellow('To use this template, you must update following to modules:'))
-    console.log()
-
-    for (let i = 0; i < warnings.length; i++) {
-      const warning = warnings[i]
-      console.log('  ' + warning)
-    }
-
-    console.log()
-    process.exit(1)
-  }
-}

build/utils.js

@@ -1,101 +0,0 @@
-'use strict'
-const path = require('path')
-const config = require('../config')
-const ExtractTextPlugin = require('extract-text-webpack-plugin')
-const packageConfig = require('../package.json')
-
-exports.assetsPath = function (_path) {
-  const assetsSubDirectory = process.env.NODE_ENV === 'production'
-    ? config.build.assetsSubDirectory
-    : config.dev.assetsSubDirectory
-
-  return path.posix.join(assetsSubDirectory, _path)
-}
-
-exports.cssLoaders = function (options) {
-  options = options || {}
-
-  const cssLoader = {
-    loader: 'css-loader',
-    options: {
-      sourceMap: options.sourceMap
-    }
-  }
-
-  const postcssLoader = {
-    loader: 'postcss-loader',
-    options: {
-      sourceMap: options.sourceMap
-    }
-  }
-
-  // generate loader string to be used with extract text plugin
-  function generateLoaders (loader, loaderOptions) {
-    const loaders = options.usePostCSS ? [cssLoader, postcssLoader] : [cssLoader]
-
-    if (loader) {
-      loaders.push({
-        loader: loader + '-loader',
-        options: Object.assign({}, loaderOptions, {
-          sourceMap: options.sourceMap
-        })
-      })
-    }
-
-    // Extract CSS when that option is specified
-    // (which is the case during production build)
-    if (options.extract) {
-      return ExtractTextPlugin.extract({
-        use: loaders,
-        fallback: 'vue-style-loader'
-      })
-    } else {
-      return ['vue-style-loader'].concat(loaders)
-    }
-  }
-
-  // https://vue-loader.vuejs.org/en/configurations/extract-css.html
-  return {
-    css: generateLoaders(),
-    postcss: generateLoaders(),
-    less: generateLoaders('less'),
-    sass: generateLoaders('sass', { indentedSyntax: true }),
-    scss: generateLoaders('sass'),
-    stylus: generateLoaders('stylus'),
-    styl: generateLoaders('stylus')
-  }
-}
-
-// Generate loaders for standalone style files (outside of .vue)
-exports.styleLoaders = function (options) {
-  const output = []
-  const loaders = exports.cssLoaders(options)
-
-  for (const extension in loaders) {
-    const loader = loaders[extension]
-    output.push({
-      test: new RegExp('\\.' + extension + '$'),
-      use: loader
-    })
-  }
-
-  return output
-}
-
-exports.createNotifierCallback = () => {
-  const notifier = require('node-notifier')
-
-  return (severity, errors) => {
-    if (severity !== 'error') return
-
-    const error = errors[0]
-    const filename = error.file && error.file.split('!').pop()
-
-    notifier.notify({
-      title: packageConfig.name,
-      message: severity + ': ' + error.name,
-      subtitle: filename || '',
-      icon: path.join(__dirname, 'logo.png')
-    })
-  }
-}

build/vue-loader.conf.js

@@ -1,22 +0,0 @@
-'use strict'
-const utils = require('./utils')
-const config = require('../config')
-const isProduction = process.env.NODE_ENV === 'production'
-const sourceMapEnabled = isProduction
-  ? config.build.productionSourceMap
-  : config.dev.cssSourceMap
-
-module.exports = {
-  loaders: utils.cssLoaders({
-    sourceMap: sourceMapEnabled,
-    extract: isProduction
-  }),
-  cssSourceMap: sourceMapEnabled,
-  cacheBusting: config.dev.cacheBusting,
-  transformToRequire: {
-    video: ['src', 'poster'],
-    source: 'src',
-    img: 'src',
-    image: 'xlink:href'
-  }
-}

build/webpack.base.conf.js

@@ -1,82 +0,0 @@
-'use strict'
-const path = require('path')
-const utils = require('./utils')
-const config = require('../config')
-const vueLoaderConfig = require('./vue-loader.conf')
-
-function resolve (dir) {
-  return path.join(__dirname, '..', dir)
-}
-
-
-
-module.exports = {
-  context: path.resolve(__dirname, '../'),
-  entry: {
-    app: './src/main.js'
-  },
-  output: {
-    path: config.build.assetsRoot,
-    filename: '[name].js',
-    publicPath: process.env.NODE_ENV === 'production'
-      ? config.build.assetsPublicPath
-      : config.dev.assetsPublicPath
-  },
-  resolve: {
-    extensions: ['.js', '.vue', '.json'],
-    alias: {
-      'vue$': 'vue/dist/vue.esm.js',
-      '@': resolve('src'),
-    }
-  },
-  module: {
-    rules: [
-      {
-        test: /\.vue$/,
-        loader: 'vue-loader',
-        options: vueLoaderConfig
-      },
-      {
-        test: /\.js$/,
-        loader: 'babel-loader',
-        include: [resolve('src'), resolve('test'), resolve('node_modules/webpack-dev-server/client')]
-      },
-      {
-        test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('img/[name].[hash:7].[ext]')
-        }
-      },
-      {
-        test: /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('media/[name].[hash:7].[ext]')
-        }
-      },
-      {
-        test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('fonts/[name].[hash:7].[ext]')
-        }
-      }
-    ]
-  },
-  node: {
-    // prevent webpack from injecting useless setImmediate polyfill because Vue
-    // source contains it (although only uses it if it's native).
-    setImmediate: false,
-    // 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'
-  }
-}

build/webpack.dev.conf.js

@@ -1,95 +0,0 @@
-'use strict'
-const utils = require('./utils')
-const webpack = require('webpack')
-const config = require('../config')
-const merge = require('webpack-merge')
-const path = require('path')
-const baseWebpackConfig = require('./webpack.base.conf')
-const CopyWebpackPlugin = require('copy-webpack-plugin')
-const HtmlWebpackPlugin = require('html-webpack-plugin')
-const FriendlyErrorsPlugin = require('friendly-errors-webpack-plugin')
-const portfinder = require('portfinder')
-
-const HOST = process.env.HOST
-const PORT = process.env.PORT && Number(process.env.PORT)
-
-const devWebpackConfig = merge(baseWebpackConfig, {
-  module: {
-    rules: utils.styleLoaders({ sourceMap: config.dev.cssSourceMap, usePostCSS: true })
-  },
-  // cheap-module-eval-source-map is faster for development
-  devtool: config.dev.devtool,
-
-  // these devServer options should be customized in /config/index.js
-  devServer: {
-    clientLogLevel: 'warning',
-    historyApiFallback: {
-      rewrites: [
-        { from: /.*/, to: path.posix.join(config.dev.assetsPublicPath, 'index.html') },
-      ],
-    },
-    hot: true,
-    contentBase: false, // since we use CopyWebpackPlugin.
-    compress: true,
-    host: HOST || config.dev.host,
-    port: PORT || config.dev.port,
-    open: config.dev.autoOpenBrowser,
-    overlay: config.dev.errorOverlay
-      ? { warnings: false, errors: true }
-      : false,
-    publicPath: config.dev.assetsPublicPath,
-    proxy: config.dev.proxyTable,
-    quiet: true, // necessary for FriendlyErrorsPlugin
-    watchOptions: {
-      poll: config.dev.poll,
-    }
-  },
-  plugins: [
-    new webpack.DefinePlugin({
-      'process.env': require('../config/dev.env')
-    }),
-    new webpack.HotModuleReplacementPlugin(),
-    new webpack.NamedModulesPlugin(), // HMR shows correct file names in console on update.
-    new webpack.NoEmitOnErrorsPlugin(),
-    // https://github.com/ampedandwired/html-webpack-plugin
-    new HtmlWebpackPlugin({
-      filename: 'index.html',
-      template: 'index.html',
-      inject: true
-    }),
-    // copy custom static assets
-    new CopyWebpackPlugin([
-      {
-        from: path.resolve(__dirname, '../static'),
-        to: config.dev.assetsSubDirectory,
-        ignore: ['.*']
-      }
-    ])
-  ]
-})
-
-module.exports = new Promise((resolve, reject) => {
-  portfinder.basePort = process.env.PORT || config.dev.port
-  portfinder.getPort((err, port) => {
-    if (err) {
-      reject(err)
-    } else {
-      // publish the new Port, necessary for e2e tests
-      process.env.PORT = port
-      // add port to devServer config
-      devWebpackConfig.devServer.port = port
-
-      // Add FriendlyErrorsPlugin
-      devWebpackConfig.plugins.push(new FriendlyErrorsPlugin({
-        compilationSuccessInfo: {
-          messages: [`Your application is running here: http://${devWebpackConfig.devServer.host}:${port}`],
-        },
-        onErrors: config.dev.notifyOnErrors
-        ? utils.createNotifierCallback()
-        : undefined
-      }))
-
-      resolve(devWebpackConfig)
-    }
-  })
-})

build/webpack.prod.conf.js

@@ -1,145 +0,0 @@
-'use strict'
-const path = require('path')
-const utils = require('./utils')
-const webpack = require('webpack')
-const config = require('../config')
-const merge = require('webpack-merge')
-const baseWebpackConfig = require('./webpack.base.conf')
-const CopyWebpackPlugin = require('copy-webpack-plugin')
-const HtmlWebpackPlugin = require('html-webpack-plugin')
-const ExtractTextPlugin = require('extract-text-webpack-plugin')
-const OptimizeCSSPlugin = require('optimize-css-assets-webpack-plugin')
-const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
-
-const env = require('../config/prod.env')
-
-const webpackConfig = merge(baseWebpackConfig, {
-  module: {
-    rules: utils.styleLoaders({
-      sourceMap: config.build.productionSourceMap,
-      extract: true,
-      usePostCSS: true
-    })
-  },
-  devtool: config.build.productionSourceMap ? config.build.devtool : false,
-  output: {
-    path: config.build.assetsRoot,
-    filename: utils.assetsPath('js/[name].[chunkhash].js'),
-    chunkFilename: utils.assetsPath('js/[id].[chunkhash].js')
-  },
-  plugins: [
-    // http://vuejs.github.io/vue-loader/en/workflow/production.html
-    new webpack.DefinePlugin({
-      'process.env': env
-    }),
-    new UglifyJsPlugin({
-      uglifyOptions: {
-        compress: {
-          warnings: false
-        }
-      },
-      sourceMap: config.build.productionSourceMap,
-      parallel: true
-    }),
-    // extract css into its own file
-    new ExtractTextPlugin({
-      filename: utils.assetsPath('css/[name].[contenthash].css'),
-      // Setting the following option to `false` will not extract CSS from codesplit chunks.
-      // Their CSS will instead be inserted dynamically with style-loader when the codesplit chunk has been loaded by webpack.
-      // It's currently set to `true` because we are seeing that sourcemaps are included in the codesplit bundle as well when it's `false`, 
-      // increasing file size: https://github.com/vuejs-templates/webpack/issues/1110
-      allChunks: true,
-    }),
-    // Compress extracted CSS. We are using this plugin so that possible
-    // duplicated CSS from different components can be deduped.
-    new OptimizeCSSPlugin({
-      cssProcessorOptions: config.build.productionSourceMap
-        ? { safe: true, map: { inline: false } }
-        : { safe: true }
-    }),
-    // generate dist index.html with correct asset hash for caching.
-    // you can customize output by editing /index.html
-    // see https://github.com/ampedandwired/html-webpack-plugin
-    new HtmlWebpackPlugin({
-      filename: config.build.index,
-      template: 'index.html',
-      inject: true,
-      minify: {
-        removeComments: true,
-        collapseWhitespace: true,
-        removeAttributeQuotes: true
-        // more options:
-        // https://github.com/kangax/html-minifier#options-quick-reference
-      },
-      // necessary to consistently work with multiple chunks via CommonsChunkPlugin
-      chunksSortMode: 'dependency'
-    }),
-    // keep module.id stable when vendor modules does not change
-    new webpack.HashedModuleIdsPlugin(),
-    // enable scope hoisting
-    new webpack.optimize.ModuleConcatenationPlugin(),
-    // split vendor js into its own file
-    new webpack.optimize.CommonsChunkPlugin({
-      name: 'vendor',
-      minChunks (module) {
-        // any required modules inside node_modules are extracted to vendor
-        return (
-          module.resource &&
-          /\.js$/.test(module.resource) &&
-          module.resource.indexOf(
-            path.join(__dirname, '../node_modules')
-          ) === 0
-        )
-      }
-    }),
-    // extract webpack runtime and module manifest to its own file in order to
-    // prevent vendor hash from being updated whenever app bundle is updated
-    new webpack.optimize.CommonsChunkPlugin({
-      name: 'manifest',
-      minChunks: Infinity
-    }),
-    // This instance extracts shared chunks from code splitted chunks and bundles them
-    // in a separate chunk, similar to the vendor chunk
-    // see: https://webpack.js.org/plugins/commons-chunk-plugin/#extra-async-commons-chunk
-    new webpack.optimize.CommonsChunkPlugin({
-      name: 'app',
-      async: 'vendor-async',
-      children: true,
-      minChunks: 3
-    }),
-
-    // copy custom static assets
-    new CopyWebpackPlugin([
-      {
-        from: path.resolve(__dirname, '../static'),
-        to: config.build.assetsSubDirectory,
-        ignore: ['.*']
-      }
-    ])
-  ]
-})
-
-if (config.build.productionGzip) {
-  const CompressionWebpackPlugin = require('compression-webpack-plugin')
-
-  webpackConfig.plugins.push(
-    new CompressionWebpackPlugin({
-      asset: '[path].gz[query]',
-      algorithm: 'gzip',
-      test: new RegExp(
-        '\\.(' +
-        config.build.productionGzipExtensions.join('|') +
-        ')$'
-      ),
-      threshold: 10240,
-      minRatio: 0.8
-    })
-  )
-}
-
-if (config.build.bundleAnalyzerReport) {
-  const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
-  webpackConfig.plugins.push(new BundleAnalyzerPlugin())
-}
-
-module.exports = webpackConfig

config/dev.env.js

@@ -1,7 +0,0 @@
-'use strict'
-const merge = require('webpack-merge')
-const prodEnv = require('./prod.env')
-
-module.exports = merge(prodEnv, {
-  NODE_ENV: '"development"'
-})

config/index.js

@@ -1,69 +0,0 @@
-'use strict'
-// Template version: 1.3.1
-// see http://vuejs-templates.github.io/webpack for documentation.
-
-const path = require('path')
-
-module.exports = {
-  dev: {
-
-    // Paths
-    assetsSubDirectory: 'static',
-    assetsPublicPath: '/',
-    proxyTable: {},
-
-    // Various Dev Server settings
-    host: 'localhost', // can be overwritten by process.env.HOST
-    port: 8080, // can be overwritten by process.env.PORT, if port is in use, a free one will be determined
-    autoOpenBrowser: false,
-    errorOverlay: true,
-    notifyOnErrors: true,
-    poll: false, // https://webpack.js.org/configuration/dev-server/#devserver-watchoptions-
-
-    
-    /**
-     * Source Maps
-     */
-
-    // https://webpack.js.org/configuration/devtool/#development
-    devtool: 'cheap-module-eval-source-map',
-
-    // If you have problems debugging vue-files in devtools,
-    // set this to false - it *may* help
-    // https://vue-loader.vuejs.org/en/options.html#cachebusting
-    cacheBusting: true,
-
-    cssSourceMap: true
-  },
-
-  build: {
-    // Template for index.html
-    index: path.resolve(__dirname, '../dist/index.html'),
-
-    // Paths
-    assetsRoot: path.resolve(__dirname, '../dist'),
-    assetsSubDirectory: 'static',
-    assetsPublicPath: '/',
-
-    /**
-     * Source Maps
-     */
-
-    productionSourceMap: true,
-    // https://webpack.js.org/configuration/devtool/#production
-    devtool: '#source-map',
-
-    // Gzip off by default as many popular static hosts such as
-    // Surge or Netlify already gzip all static assets for you.
-    // Before setting to `true`, make sure to:
-    // npm install --save-dev compression-webpack-plugin
-    productionGzip: false,
-    productionGzipExtensions: ['js', 'css'],
-
-    // Run the build command with an extra argument to
-    // View the bundle analyzer report after build finishes:
-    // `npm run build --report`
-    // Set to `true` or `false` to always turn it on or off
-    bundleAnalyzerReport: process.env.npm_config_report
-  }
-}

config/prod.env.js

@@ -1,4 +0,0 @@
-'use strict'
-module.exports = {
-  NODE_ENV: '"production"'
-}

index.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width,initial-scale=1.0">
-    <title>校园报修后台管理系统</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <!-- built files will be auto injected -->
-  </body>
-</html>

node_modules/.bin/acorn

@@ -1 +0,0 @@
-../acorn/bin/acorn

node_modules/.bin/ansi-html

@@ -1 +0,0 @@
-../ansi-html/bin/ansi-html

node_modules/.bin/atob

@@ -1 +0,0 @@
-../atob/bin/atob.js

node_modules/.bin/autoprefixer-info

@@ -1 +0,0 @@
-../autoprefixer/bin/autoprefixer-info

node_modules/.bin/babylon

@@ -1 +0,0 @@
-../babylon/bin/babylon.js

node_modules/.bin/browserslist

@@ -1 +0,0 @@
-../browserslist/cli.js

node_modules/.bin/cssesc

@@ -1 +0,0 @@
-../cssesc/bin/cssesc

node_modules/.bin/csso

@@ -1 +0,0 @@
-../csso/bin/csso

node_modules/.bin/errno

@@ -1 +0,0 @@
-../errno/cli.js

node_modules/.bin/esparse

@@ -1 +0,0 @@
-../esprima/bin/esparse.js

node_modules/.bin/esvalidate

@@ -1 +0,0 @@
-../esprima/bin/esvalidate.js

node_modules/.bin/he

@@ -1 +0,0 @@
-../he/bin/he

node_modules/.bin/html-minifier

@@ -1 +0,0 @@
-../html-minifier/cli.js

node_modules/.bin/import-local-fixture

@@ -1 +0,0 @@
-../import-local/fixtures/cli.js

node_modules/.bin/internal-ip

@@ -1 +0,0 @@
-../internal-ip/cli.js

node_modules/.bin/js-yaml

@@ -1 +0,0 @@
-../js-yaml/bin/js-yaml.js

node_modules/.bin/jsesc

@@ -1 +0,0 @@
-../jsesc/bin/jsesc

node_modules/.bin/json5

@@ -1 +0,0 @@
-../json5/lib/cli.js

node_modules/.bin/loose-envify

@@ -1 +0,0 @@
-../loose-envify/cli.js

node_modules/.bin/miller-rabin

@@ -1 +0,0 @@
-../miller-rabin/bin/miller-rabin

node_modules/.bin/mime

@@ -1 +0,0 @@
-../mime/cli.js

node_modules/.bin/mkdirp

@@ -1 +0,0 @@
-../mkdirp/bin/cmd.js

node_modules/.bin/multicast-dns

@@ -1 +0,0 @@
-../multicast-dns/cli.js

node_modules/.bin/opener

@@ -1 +0,0 @@
-../opener/bin/opener-bin.js

node_modules/.bin/prettier

@@ -1 +0,0 @@
-../prettier/bin-prettier.js

node_modules/.bin/regjsparser

@@ -1 +0,0 @@
-../regjsparser/bin/parser

node_modules/.bin/resolve

@@ -1 +0,0 @@
-../resolve/bin/resolve

node_modules/.bin/rimraf

@@ -1 +0,0 @@
-../rimraf/bin.js

node_modules/.bin/semver

@@ -1 +0,0 @@
-../semver/bin/semver

node_modules/.bin/sha.js

@@ -1 +0,0 @@
-../sha.js/bin.js

node_modules/.bin/shjs

@@ -1 +0,0 @@
-../shelljs/bin/shjs

node_modules/.bin/strip-indent

@@ -1 +0,0 @@
-../strip-indent/cli.js

node_modules/.bin/svgo

@@ -1 +0,0 @@
-../svgo/bin/svgo

node_modules/.bin/uglifyjs

@@ -1 +0,0 @@
-../uglify-es/bin/uglifyjs

node_modules/.bin/uuid

@@ -1 +0,0 @@
-../uuid/bin/uuid

node_modules/.bin/webpack

@@ -1 +0,0 @@
-../webpack/bin/webpack.js

node_modules/.bin/webpack-bundle-analyzer

@@ -1 +0,0 @@
-../webpack-bundle-analyzer/lib/bin/analyzer.js

node_modules/.bin/webpack-dev-server

@@ -1 +0,0 @@
-../webpack-dev-server/bin/webpack-dev-server.js

node_modules/.bin/which

@@ -1 +0,0 @@
-../which/bin/which

node_modules/@types/q/LICENSE

@@ -1,21 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE

node_modules/@types/q/README.md

@@ -1,16 +0,0 @@
-# Installation
-> `npm install --save @types/q`
-
-# Summary
-This package contains type definitions for Q (https://github.com/kriskowal/q).
-
-# Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/q.
-
-### Additional Details
- * Last updated: Wed, 07 Jul 2021 17:02:41 GMT
- * Dependencies: none
- * Global values: `Q`
-
-# Credits
-These definitions were written by [Barrie Nemetchek](https://github.com/bnemetchek), [Andrew Gaspar](https://github.com/AndrewGaspar), [John Reilly](https://github.com/johnnyreilly), [Michel Boudreau](https://github.com/mboudreau), and [TeamworkGuy2](https://github.com/TeamworkGuy2).

node_modules/@types/q/index.d.ts

@@ -1,603 +0,0 @@
-// Type definitions for Q 1.5
-// Project: https://github.com/kriskowal/q
-// Definitions by: Barrie Nemetchek <https://github.com/bnemetchek>
-//                 Andrew Gaspar <https://github.com/AndrewGaspar>
-//                 John Reilly <https://github.com/johnnyreilly>
-//                 Michel Boudreau <https://github.com/mboudreau>
-//                 TeamworkGuy2 <https://github.com/TeamworkGuy2>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
-
-export = Q;
-export as namespace Q;
-
-/**
- * If value is a Q promise, returns the promise.
- * If value is a promise from another library it is coerced into a Q promise (where possible).
- * If value is not a promise, returns a promise that is fulfilled with value.
- */
-declare function Q<T>(promise: PromiseLike<T> | T): Q.Promise<T>;
-/**
- * Calling with nothing at all creates a void promise
- */
-declare function Q(): Q.Promise<void>;
-
-declare namespace Q {
-    export type IWhenable<T> = PromiseLike<T> | T;
-    export type IPromise<T> = PromiseLike<T>;
-
-    export interface Deferred<T> {
-        promise: Promise<T>;
-
-        /**
-         * Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its
-         * fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does).
-         * Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason.
-         * Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value.
-         * Calling resolve with a non-promise value causes promise to be fulfilled with that value.
-         */
-        resolve(value?: IWhenable<T>): void;
-
-        /**
-         * Calling reject with a reason causes promise to be rejected with that reason.
-         */
-        reject(reason?: any): void;
-
-        /**
-         * Calling notify with a value causes promise to be notified of progress with that value. That is, any onProgress
-         * handlers registered with promise or promises derived from promise will be called with the progress value.
-         */
-        notify(value: any): void;
-
-        /**
-         * Returns a function suitable for passing to a Node.js API. That is, it has a signature (err, result) and will
-         * reject deferred.promise with err if err is given, or fulfill it with result if that is given.
-         */
-        makeNodeResolver(): (reason: any, value: T) => void;
-    }
-
-    export interface Promise<T> {
-        /**
-         * The then method from the Promises/A+ specification, with an additional progress handler.
-         */
-        then<U>(onFulfill?: ((value: T) => IWhenable<U>) | null, onReject?: ((error: any) => IWhenable<U>) | null, onProgress?: ((progress: any) => any) | null): Promise<U>;
-        then<U = T, V = never>(onFulfill?: ((value: T) => IWhenable<U>) | null, onReject?: ((error: any) => IWhenable<V>) | null, onProgress?: ((progress: any) => any) | null): Promise<U | V>;
-        /**
-         * Like a finally clause, allows you to observe either the fulfillment or rejection of a promise, but to do so
-         * without modifying the final value. This is useful for collecting resources regardless of whether a job succeeded,
-         * like closing a database connection, shutting a server down, or deleting an unneeded key from an object.
-         * finally returns a promise, which will become resolved with the same fulfillment value or rejection reason
-         * as promise. However, if callback returns a promise, the resolution of the returned promise will be delayed
-         * until the promise returned from callback is finished. Furthermore, if the returned promise rejects, that
-         * rejection will be passed down the chain instead of the previous result.
-         */
-        finally(finallyCallback: () => any): Promise<T>;
-
-        /**
-         * Alias for finally() (for non-ES5 browsers)
-         */
-        fin(finallyCallback: () => any): Promise<T>;
-
-        /**
-         * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are
-         * rejected, instead calls onRejected with the first rejected promise's rejection reason.
-         * This is especially useful in conjunction with all
-         */
-        spread<U>(onFulfill: (...args: any[]) => IWhenable<U>, onReject?: (reason: any) => IWhenable<U>): Promise<U>;
-
-        /**
-         * A sugar method, equivalent to promise.then(undefined, onRejected).
-         */
-        catch<U>(onRejected: (reason: any) => IWhenable<U>): Promise<U>;
-
-        /**
-         * Alias for catch() (for non-ES5 browsers)
-         */
-        fail<U>(onRejected: (reason: any) => IWhenable<U>): Promise<U>;
-
-        /**
-         * A sugar method, equivalent to promise.then(undefined, undefined, onProgress).
-         */
-        progress(onProgress: (progress: any) => any): Promise<T>;
-
-        /**
-         * Much like then, but with different behavior around unhandled rejection. If there is an unhandled rejection,
-         * either because promise is rejected and no onRejected callback was provided, or because onFulfilled or onRejected
-         * threw an error or returned a rejected promise, the resulting rejection reason is thrown as an exception in a
-         * future turn of the event loop.
-         * This method should be used to terminate chains of promises that will not be passed elsewhere. Since exceptions
-         * thrown in then callbacks are consumed and transformed into rejections, exceptions at the end of the chain are
-         * easy to accidentally, silently ignore. By arranging for the exception to be thrown in a future turn of the
-         * event loop, so that it won't be caught, it causes an onerror event on the browser window, or an uncaughtException
-         * event on Node.js's process object.
-         * Exceptions thrown by done will have long stack traces, if Q.longStackSupport is set to true. If Q.onerror is set,
-         * exceptions will be delivered there instead of thrown in a future turn.
-         * The Golden Rule of done vs. then usage is: either return your promise to someone else, or if the chain ends
-         * with you, call done to terminate it. Terminating with catch is not sufficient because the catch handler may
-         * itself throw an error.
-         */
-        done(onFulfilled?: ((value: T) => any) | null, onRejected?: ((reason: any) => any) | null, onProgress?: ((progress: any) => any) | null): void;
-
-        /**
-         * If callback is a function, assumes it's a Node.js-style callback, and calls it as either callback(rejectionReason)
-         * when/if promise becomes rejected, or as callback(null, fulfillmentValue) when/if promise becomes fulfilled.
-         * If callback is not a function, simply returns promise.
-         */
-        nodeify(callback: (reason: any, value: any) => void): Promise<T>;
-
-        /**
-         * Returns a promise to get the named property of an object. Essentially equivalent to
-         *
-         * @example
-         * promise.then(function (o) { return o[propertyName]; });
-         */
-        get<U>(propertyName: string): Promise<U>;
-
-        set<U>(propertyName: string, value: any): Promise<U>;
-
-        delete<U>(propertyName: string): Promise<U>;
-
-        /**
-         * Returns a promise for the result of calling the named method of an object with the given array of arguments.
-         * The object itself is this in the function, just like a synchronous method call. Essentially equivalent to
-         *
-         * @example
-         * promise.then(function (o) { return o[methodName].apply(o, args); });
-         */
-        post<U>(methodName: string, args: any[]): Promise<U>;
-
-        /**
-         * Returns a promise for the result of calling the named method of an object with the given variadic arguments.
-         * The object itself is this in the function, just like a synchronous method call.
-         */
-        invoke<U>(methodName: string, ...args: any[]): Promise<U>;
-
-        /**
-         * Returns a promise for an array of the property names of an object. Essentially equivalent to
-         *
-         * @example
-         * promise.then(function (o) { return Object.keys(o); });
-         */
-        keys(): Promise<string[]>;
-
-        /**
-         * Returns a promise for the result of calling a function, with the given array of arguments. Essentially equivalent to
-         *
-         * @example
-         * promise.then(function (f) {
-         *     return f.apply(undefined, args);
-         * });
-         */
-        fapply<U>(args: any[]): Promise<U>;
-
-        /**
-         * Returns a promise for the result of calling a function, with the given variadic arguments. Has the same return
-         * value/thrown exception translation as explained above for fbind.
-         * In its static form, it is aliased as Q.try, since it has semantics similar to a try block (but handling both
-         * synchronous exceptions and asynchronous rejections). This allows code like
-         *
-         * @example
-         * Q.try(function () {
-         *     if (!isConnectedToCloud()) {
-         *         throw new Error("The cloud is down!");
-         *     }
-         *     return syncToCloud();
-         * })
-         * .catch(function (error) {
-         *     console.error("Couldn't sync to the cloud", error);
-         * });
-         */
-        fcall<U>(...args: any[]): Promise<U>;
-
-        /**
-         * A sugar method, equivalent to promise.then(function () { return value; }).
-         */
-        thenResolve<U>(value: U): Promise<U>;
-
-        /**
-         * A sugar method, equivalent to promise.then(function () { throw reason; }).
-         */
-        thenReject<U = T>(reason?: any): Promise<U>;
-
-        /**
-         * Attaches a handler that will observe the value of the promise when it becomes fulfilled, returning a promise for
-         * that same value, perhaps deferred but not replaced by the promise returned by the onFulfilled handler.
-         */
-        tap(onFulfilled: (value: T) => any): Promise<T>;
-
-        /**
-         * Returns a promise that will have the same result as promise, except that if promise is not fulfilled or rejected
-         * before ms milliseconds, the returned promise will be rejected with an Error with the given message. If message
-         * is not supplied, the message will be "Timed out after " + ms + " ms".
-         */
-        timeout(ms: number, message?: string): Promise<T>;
-
-        /**
-         * Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least
-         * ms milliseconds have passed.
-         */
-        delay(ms: number): Promise<T>;
-
-        /**
-         * Returns whether a given promise is in the fulfilled state. When the static version is used on non-promises, the
-         * result is always true.
-         */
-        isFulfilled(): boolean;
-
-        /**
-         * Returns whether a given promise is in the rejected state. When the static version is used on non-promises, the
-         * result is always false.
-         */
-        isRejected(): boolean;
-
-        /**
-         * Returns whether a given promise is in the pending state. When the static version is used on non-promises, the
-         * result is always false.
-         */
-        isPending(): boolean;
-
-        valueOf(): any;
-
-        /**
-         * Returns a "state snapshot" object, which will be in one of three forms:
-         *
-         * - { state: "pending" }
-         * - { state: "fulfilled", value: <fulfllment value> }
-         * - { state: "rejected", reason: <rejection reason> }
-         */
-        inspect(): PromiseState<T>;
-    }
-
-    export interface PromiseState<T> {
-        state: "fulfilled" | "rejected" | "pending";
-        value?: T | undefined;
-        reason?: any;
-    }
-
-    /**
-     * Returns a "deferred" object with a:
-     * promise property
-     * resolve(value) method
-     * reject(reason) method
-     * notify(value) method
-     * makeNodeResolver() method
-     */
-    export function defer<T>(): Deferred<T>;
-
-    /**
-     * Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its
-     * fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does).
-     * Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason.
-     * Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value.
-     * Calling resolve with a non-promise value causes promise to be fulfilled with that value.
-     */
-    export function resolve<T>(object?: IWhenable<T>): Promise<T>;
-
-    /**
-     * Returns a promise that is rejected with reason.
-     */
-    export function reject<T>(reason?: any): Promise<T>;
-
-    // If no value provided, returned promise will be of void type
-    export function when(): Promise<void>;
-
-    // if no fulfill, reject, or progress provided, returned promise will be of same type
-    export function when<T>(value: IWhenable<T>): Promise<T>;
-
-    // If a non-promise value is provided, it will not reject or progress
-    export function when<T, U>(
-        value: IWhenable<T>,
-        onFulfilled: (val: T) => IWhenable<U>,
-        onRejected?: ((reason: any) => IWhenable<U>) | null,
-        onProgress?: ((progress: any) => any) | null
-    ): Promise<U>;
-
-    /**
-     * (Deprecated) Returns a new function that calls a function asynchronously with the given variadic arguments, and returns a promise.
-     * Notably, any synchronous return values or thrown exceptions are transformed, respectively, into fulfillment values
-     * or rejection reasons for the promise returned by this new function.
-     * This method is especially useful in its static form for wrapping functions to ensure that they are always
-     * asynchronous, and that any thrown exceptions (intentional or accidental) are appropriately transformed into a
-     * returned rejected promise. For example:
-     *
-     * @example
-     * var getUserData = Q.fbind(function (userName) {
-     *     if (!userName) {
-     *         throw new Error("userName must be truthy!");
-     *     }
-     *     if (localCache.has(userName)) {
-     *         return localCache.get(userName);
-     *     }
-     *     return getUserFromCloud(userName);
-     * });
-     */
-    export function fbind<T>(method: (...args: any[]) => IWhenable<T>, ...args: any[]): (...args: any[]) => Promise<T>;
-
-    /**
-     * Returns a promise for the result of calling a function, with the given variadic arguments. Has the same return
-     * value/thrown exception translation as explained above for fbind.
-     * In its static form, it is aliased as Q.try, since it has semantics similar to a try block (but handling both synchronous
-     * exceptions and asynchronous rejections). This allows code like
-     *
-     * @example
-     * Q.try(function () {
-     *     if (!isConnectedToCloud()) {
-     *         throw new Error("The cloud is down!");
-     *     }
-     *     return syncToCloud();
-     * })
-     * .catch(function (error) {
-     *     console.error("Couldn't sync to the cloud", error);
-     * });
-     */
-    export function fcall<T>(method: (...args: any[]) => T, ...args: any[]): Promise<T>;
-
-    // but 'try' is a reserved word.  This is the only way to get around this
-    /**
-     * Alias for fcall()
-     */
-    export { fcall as try };
-
-    /**
-     * Returns a promise for the result of calling the named method of an object with the given variadic arguments.
-     * The object itself is this in the function, just like a synchronous method call.
-     */
-    export function invoke<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;
-
-    /**
-     * Alias for invoke()
-     */
-    export function send<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;
-
-    /**
-     * Alias for invoke()
-     */
-    export function mcall<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;
-
-    /**
-     * Creates a promise-returning function from a Node.js-style function, optionally binding it with the given
-     * variadic arguments. An example:
-     *
-     * @example
-     * var readFile = Q.nfbind(FS.readFile);
-     * readFile("foo.txt", "utf-8").done(function (text) {
-     *     //...
-     * });
-     *
-     * Note that if you have a method that uses the Node.js callback pattern, as opposed to just a function, you will
-     * need to bind its this value before passing it to nfbind, like so:
-     *
-     * @example
-     * var Kitty = mongoose.model("Kitty");
-     * var findKitties = Q.nfbind(Kitty.find.bind(Kitty));
-     *
-     * The better strategy for methods would be to use Q.nbind, as shown below.
-     */
-    export function nfbind<T>(nodeFunction: (...args: any[]) => any, ...args: any[]): (...args: any[]) => Promise<T>;
-
-    /**
-     * Alias for nfbind()
-     */
-    export function denodeify<T>(nodeFunction: (...args: any[]) => any, ...args: any[]): (...args: any[]) => Promise<T>;
-
-    /**
-     * Creates a promise-returning function from a Node.js-style method, optionally binding it with the given
-     * variadic arguments. An example:
-     *
-     * @example
-     * var Kitty = mongoose.model("Kitty");
-     * var findKitties = Q.nbind(Kitty.find, Kitty);
-     * findKitties({ cute: true }).done(function (theKitties) {
-     *     //...
-     * });
-     */
-    export function nbind<T>(nodeFunction: (...args: any[]) => any, thisArg: any, ...args: any[]): (...args: any[]) => Promise<T>;
-
-    /**
-     * Calls a Node.js-style function with the given array of arguments, returning a promise that is fulfilled if the
-     * Node.js function calls back with a result, or rejected if it calls back with an error
-     * (or throws one synchronously). An example:
-     *
-     * @example
-     * Q.nfapply(FS.readFile, ["foo.txt", "utf-8"]).done(function (text) {
-     * });
-     *
-     * Note that this example only works because FS.readFile is a function exported from a module, not a method on
-     * an object. For methods, e.g. redisClient.get, you must bind the method to an instance before passing it to
-     * Q.nfapply (or, generally, as an argument to any function call):
-     *
-     * @example
-     * Q.nfapply(redisClient.get.bind(redisClient), ["user:1:id"]).done(function (user) {
-     * });
-     *
-     * The better strategy for methods would be to use Q.npost, as shown below.
-     */
-    export function nfapply<T>(nodeFunction: (...args: any[]) => any, args: any[]): Promise<T>;
-
-    /**
-     * Calls a Node.js-style function with the given variadic arguments, returning a promise that is fulfilled if the
-     * Node.js function calls back with a result, or rejected if it calls back with an error
-     * (or throws one synchronously). An example:
-     *
-     * @example
-     * Q.nfcall(FS.readFile, "foo.txt", "utf-8").done(function (text) {
-     * });
-     *
-     * The same warning about functions vs. methods applies for nfcall as it does for nfapply. In this case, the better
-     * strategy would be to use Q.ninvoke.
-     */
-    export function nfcall<T>(nodeFunction: (...args: any[]) => any, ...args: any[]): Promise<T>;
-
-    /**
-     * Calls a Node.js-style method with the given arguments array, returning a promise that is fulfilled if the method
-     * calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:
-     *
-     * @example
-     * Q.npost(redisClient, "get", ["user:1:id"]).done(function (user) {
-     * });
-     */
-    export function npost<T>(nodeModule: any, functionName: string, args: any[]): Promise<T>;
-
-    /**
-     * Calls a Node.js-style method with the given variadic arguments, returning a promise that is fulfilled if the
-     * method calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:
-     *
-     * @example
-     * Q.ninvoke(redisClient, "get", "user:1:id").done(function (user) {
-     * });
-     */
-    export function ninvoke<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;
-
-    /**
-     * Alias for ninvoke()
-     */
-    export function nsend<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;
-
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<A, B, C, D, E, F>(promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>, IWhenable<D>, IWhenable<E>, IWhenable<F>]>): Promise<[A, B, C, D, E, F]>;
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<A, B, C, D, E>(promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>, IWhenable<D>, IWhenable<E>]>): Promise<[A, B, C, D, E]>;
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<A, B, C, D>(promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>, IWhenable<D>]>): Promise<[A, B, C, D]>;
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<A, B, C>(promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>]>): Promise<[A, B, C]>;
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<A, B>(promises: IWhenable<[IPromise<A>, IPromise<B>]>): Promise<[A, B]>;
-    export function all<A, B>(promises: IWhenable<[A, IPromise<B>]>): Promise<[A, B]>;
-    export function all<A, B>(promises: IWhenable<[IPromise<A>, B]>): Promise<[A, B]>;
-    export function all<A, B>(promises: IWhenable<[A, B]>): Promise<[A, B]>;
-    /**
-     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
-     */
-    export function all<T>(promises: IWhenable<Array<IWhenable<T>>>): Promise<T[]>;
-
-    /**
-     * Returns a promise for the first of an array of promises to become settled.
-     */
-    export function race<T>(promises: Array<IWhenable<T>>): Promise<T>;
-
-    /**
-     * Returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises
-     * have settled, i.e. become either fulfilled or rejected.
-     */
-    export function allSettled<T>(promises: IWhenable<Array<IWhenable<T>>>): Promise<Array<PromiseState<T>>>;
-
-    /**
-     * Deprecated Alias for allSettled()
-     */
-    export function allResolved<T>(promises: IWhenable<Array<IWhenable<T>>>): Promise<Array<Promise<T>>>;
-
-    /**
-     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are
-     * rejected, instead calls onRejected with the first rejected promise's rejection reason. This is especially useful
-     * in conjunction with all.
-     */
-    export function spread<T, U>(promises: Array<IWhenable<T>>, onFulfilled: (...args: T[]) => IWhenable<U>, onRejected?: (reason: any) => IWhenable<U>): Promise<U>;
-
-    /**
-     * Returns a promise that will have the same result as promise, except that if promise is not fulfilled or rejected
-     * before ms milliseconds, the returned promise will be rejected with an Error with the given message. If message
-     * is not supplied, the message will be "Timed out after " + ms + " ms".
-     */
-    export function timeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
-
-    /**
-     * Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least ms milliseconds have passed.
-     */
-    export function delay<T>(promiseOrValue: Promise<T> | T, ms: number): Promise<T>;
-    /**
-     * Returns a promise that will be fulfilled with undefined after at least ms milliseconds have passed.
-     */
-    export function delay(ms: number): Promise<void>;
-
-    /**
-     * Returns whether a given promise is in the fulfilled state. When the static version is used on non-promises, the result is always true.
-     */
-    export function isFulfilled(promise: Promise<any>): boolean;
-
-    /**
-     * Returns whether a given promise is in the rejected state. When the static version is used on non-promises, the result is always false.
-     */
-    export function isRejected(promise: Promise<any>): boolean;
-
-    /**
-     * Returns whether a given promise is in the pending state. When the static version is used on non-promises, the result is always false.
-     */
-    export function isPending(promiseOrObject: Promise<any> | any): boolean;
-
-    /**
-     * Synchronously calls resolver(resolve, reject, notify) and returns a promise whose state is controlled by the
-     * functions passed to resolver. This is an alternative promise-creation API that has the same power as the deferred
-     * concept, but without introducing another conceptual entity.
-     * If resolver throws an exception, the returned promise will be rejected with that thrown exception as the rejection reason.
-     * note: In the latest github, this method is called Q.Promise, but if you are using the npm package version 0.9.7
-     * or below, the method is called Q.promise (lowercase vs uppercase p).
-     */
-    export function Promise<T>(resolver: (resolve: (val?: IWhenable<T>) => void, reject: (reason?: any) => void, notify: (progress: any) => void) => void): Promise<T>;
-
-    /**
-     * Creates a new version of func that accepts any combination of promise and non-promise values, converting them to their
-     * fulfillment values before calling the original func. The returned version also always returns a promise: if func does
-     * a return or throw, then Q.promised(func) will return fulfilled or rejected promise, respectively.
-     * This can be useful for creating functions that accept either promises or non-promise values, and for ensuring that
-     * the function always returns a promise even in the face of unintentional thrown exceptions.
-     */
-    export function promised<T>(callback: (...args: any[]) => T): (...args: any[]) => Promise<T>;
-
-    /**
-     * Returns whether the given value is a Q promise.
-     */
-    export function isPromise(object: any): object is Promise<any>;
-
-    /**
-     * Returns whether the given value is a promise (i.e. it's an object with a then function).
-     */
-    export function isPromiseAlike(object: any): object is IPromise<any>;
-
-    /**
-     * If an object is not a promise, it is as "near" as possible.
-     * If a promise is rejected, it is as "near" as possible too.
-     * If it's a fulfilled promise, the fulfillment value is nearer.
-     * If it's a deferred promise and the deferred has been resolved, the
-     * resolution is "nearer".
-     */
-    export function nearer<T>(promise: Promise<T>): T;
-
-    /**
-     * This is an experimental tool for converting a generator function into a deferred function. This has the potential
-     * of reducing nested callbacks in engines that support yield.
-     */
-    export function async<T>(generatorFunction: any): (...args: any[]) => Promise<T>;
-
-    export function nextTick(callback: (...args: any[]) => any): void;
-
-    /**
-     * A settable property that will intercept any uncaught errors that would otherwise be thrown in the next tick of the
-     * event loop, usually as a result of done. Can be useful for getting the full
-     * stack trace of an error in browsers, which is not usually possible with window.onerror.
-     */
-    export let onerror: (reason: any) => void;
-    /**
-     * A settable property that lets you turn on long stack trace support. If turned on, "stack jumps" will be tracked
-     * across asynchronous promise operations, so that if an uncaught error is thrown by done or a rejection reason's stack
-     * property is inspected in a rejection callback, a long stack trace is produced.
-     */
-    export let longStackSupport: boolean;
-
-    /**
-     * Resets the global "Q" variable to the value it has before Q was loaded.
-     * This will either be undefined if there was no version or the version of Q which was already loaded before.
-     * @returns The last version of Q.
-     */
-    export function noConflict(): typeof Q;
-}

node_modules/@types/q/package.json

@@ -1,45 +0,0 @@
-{
-    "name": "@types/q",
-    "version": "1.5.5",
-    "description": "TypeScript definitions for Q",
-    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/q",
-    "license": "MIT",
-    "contributors": [
-        {
-            "name": "Barrie Nemetchek",
-            "url": "https://github.com/bnemetchek",
-            "githubUsername": "bnemetchek"
-        },
-        {
-            "name": "Andrew Gaspar",
-            "url": "https://github.com/AndrewGaspar",
-            "githubUsername": "AndrewGaspar"
-        },
-        {
-            "name": "John Reilly",
-            "url": "https://github.com/johnnyreilly",
-            "githubUsername": "johnnyreilly"
-        },
-        {
-            "name": "Michel Boudreau",
-            "url": "https://github.com/mboudreau",
-            "githubUsername": "mboudreau"
-        },
-        {
-            "name": "TeamworkGuy2",
-            "url": "https://github.com/TeamworkGuy2",
-            "githubUsername": "TeamworkGuy2"
-        }
-    ],
-    "main": "",
-    "types": "index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
-        "directory": "types/q"
-    },
-    "scripts": {},
-    "dependencies": {},
-    "typesPublisherContentHash": "e35c02431c6153cb4f7280c296d68c5dead5ce1584c60e4fe11b5132cbf41b3f",
-    "typeScriptVersion": "3.6"
-}

node_modules/accepts/HISTORY.md

@@ -1,243 +0,0 @@
-1.3.8 / 2022-02-02
-==================
-
-  * deps: mime-types@~2.1.34
-    - deps: mime-db@~1.51.0
-  * deps: negotiator@0.6.3
-
-1.3.7 / 2019-04-29
-==================
-
-  * deps: negotiator@0.6.2
-    - Fix sorting charset, encoding, and language with extra parameters
-
-1.3.6 / 2019-04-28
-==================
-
-  * deps: mime-types@~2.1.24
-    - deps: mime-db@~1.40.0
-
-1.3.5 / 2018-02-28
-==================
-
-  * deps: mime-types@~2.1.18
-    - deps: mime-db@~1.33.0
-
-1.3.4 / 2017-08-22
-==================
-
-  * deps: mime-types@~2.1.16
-    - deps: mime-db@~1.29.0
-
-1.3.3 / 2016-05-02
-==================
-
-  * deps: mime-types@~2.1.11
-    - deps: mime-db@~1.23.0
-  * deps: negotiator@0.6.1
-    - perf: improve `Accept` parsing speed
-    - perf: improve `Accept-Charset` parsing speed
-    - perf: improve `Accept-Encoding` parsing speed
-    - perf: improve `Accept-Language` parsing speed
-
-1.3.2 / 2016-03-08
-==================
-
-  * deps: mime-types@~2.1.10
-    - Fix extension of `application/dash+xml`
-    - Update primary extension for `audio/mp4`
-    - deps: mime-db@~1.22.0
-
-1.3.1 / 2016-01-19
-==================
-
-  * deps: mime-types@~2.1.9
-    - deps: mime-db@~1.21.0
-
-1.3.0 / 2015-09-29
-==================
-
-  * deps: mime-types@~2.1.7
-    - deps: mime-db@~1.19.0
-  * deps: negotiator@0.6.0
-    - Fix including type extensions in parameters in `Accept` parsing
-    - Fix parsing `Accept` parameters with quoted equals
-    - Fix parsing `Accept` parameters with quoted semicolons
-    - Lazy-load modules from main entry point
-    - perf: delay type concatenation until needed
-    - perf: enable strict mode
-    - perf: hoist regular expressions
-    - perf: remove closures getting spec properties
-    - perf: remove a closure from media type parsing
-    - perf: remove property delete from media type parsing
-
-1.2.13 / 2015-09-06
-===================
-
-  * deps: mime-types@~2.1.6
-    - deps: mime-db@~1.18.0
-
-1.2.12 / 2015-07-30
-===================
-
-  * deps: mime-types@~2.1.4
-    - deps: mime-db@~1.16.0
-
-1.2.11 / 2015-07-16
-===================
-
-  * deps: mime-types@~2.1.3
-    - deps: mime-db@~1.15.0
-
-1.2.10 / 2015-07-01
-===================
-
-  * deps: mime-types@~2.1.2
-    - deps: mime-db@~1.14.0
-
-1.2.9 / 2015-06-08
-==================
-
-  * deps: mime-types@~2.1.1
-    - perf: fix deopt during mapping
-
-1.2.8 / 2015-06-07
-==================
-
-  * deps: mime-types@~2.1.0
-    - deps: mime-db@~1.13.0
-  * perf: avoid argument reassignment & argument slice
-  * perf: avoid negotiator recursive construction
-  * perf: enable strict mode
-  * perf: remove unnecessary bitwise operator
-
-1.2.7 / 2015-05-10
-==================
-
-  * deps: negotiator@0.5.3
-    - Fix media type parameter matching to be case-insensitive
-
-1.2.6 / 2015-05-07
-==================
-
-  * deps: mime-types@~2.0.11
-    - deps: mime-db@~1.9.1
-  * deps: negotiator@0.5.2
-    - Fix comparing media types with quoted values
-    - Fix splitting media types with quoted commas
-
-1.2.5 / 2015-03-13
-==================
-
-  * deps: mime-types@~2.0.10
-    - deps: mime-db@~1.8.0
-
-1.2.4 / 2015-02-14
-==================
-
-  * Support Node.js 0.6
-  * deps: mime-types@~2.0.9
-    - deps: mime-db@~1.7.0
-  * deps: negotiator@0.5.1
-    - Fix preference sorting to be stable for long acceptable lists
-
-1.2.3 / 2015-01-31
-==================
-
-  * deps: mime-types@~2.0.8
-    - deps: mime-db@~1.6.0
-
-1.2.2 / 2014-12-30
-==================
-
-  * deps: mime-types@~2.0.7
-    - deps: mime-db@~1.5.0
-
-1.2.1 / 2014-12-30
-==================
-
-  * deps: mime-types@~2.0.5
-    - deps: mime-db@~1.3.1
-
-1.2.0 / 2014-12-19
-==================
-
-  * deps: negotiator@0.5.0
-    - Fix list return order when large accepted list
-    - Fix missing identity encoding when q=0 exists
-    - Remove dynamic building of Negotiator class
-
-1.1.4 / 2014-12-10
-==================
-
-  * deps: mime-types@~2.0.4
-    - deps: mime-db@~1.3.0
-
-1.1.3 / 2014-11-09
-==================
-
-  * deps: mime-types@~2.0.3
-    - deps: mime-db@~1.2.0
-
-1.1.2 / 2014-10-14
-==================
-
-  * deps: negotiator@0.4.9
-    - Fix error when media type has invalid parameter
-
-1.1.1 / 2014-09-28
-==================
-
-  * deps: mime-types@~2.0.2
-    - deps: mime-db@~1.1.0
-  * deps: negotiator@0.4.8
-    - Fix all negotiations to be case-insensitive
-    - Stable sort preferences of same quality according to client order
-
-1.1.0 / 2014-09-02
-==================
-
-  * update `mime-types`
-
-1.0.7 / 2014-07-04
-==================
-
-  * Fix wrong type returned from `type` when match after unknown extension
-
-1.0.6 / 2014-06-24
-==================
-
-  * deps: negotiator@0.4.7
-
-1.0.5 / 2014-06-20
-==================
-
- * fix crash when unknown extension given
-
-1.0.4 / 2014-06-19
-==================
-
-  * use `mime-types`
-
-1.0.3 / 2014-06-11
-==================
-
-  * deps: negotiator@0.4.6
-    - Order by specificity when quality is the same
-
-1.0.2 / 2014-05-29
-==================
-
-  * Fix interpretation when header not in request
-  * deps: pin negotiator@0.4.5
-
-1.0.1 / 2014-01-18
-==================
-
-  * Identity encoding isn't always acceptable
-  * deps: negotiator@~0.4.0
-
-1.0.0 / 2013-12-27
-==================
-
-  * Genesis

node_modules/accepts/LICENSE

@@ -1,23 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
-Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/accepts/README.md

@@ -1,140 +0,0 @@
-# accepts
-
-[![NPM Version][npm-version-image]][npm-url]
-[![NPM Downloads][npm-downloads-image]][npm-url]
-[![Node.js Version][node-version-image]][node-version-url]
-[![Build Status][github-actions-ci-image]][github-actions-ci-url]
-[![Test Coverage][coveralls-image]][coveralls-url]
-
-Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
-Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
-
-In addition to negotiator, it allows:
-
-- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
-  as well as `('text/html', 'application/json')`.
-- Allows type shorthands such as `json`.
-- Returns `false` when no types match
-- Treats non-existent headers as `*`
-
-## Installation
-
-This is a [Node.js](https://nodejs.org/en/) module available through the
-[npm registry](https://www.npmjs.com/). Installation is done using the
-[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
-
-```sh
-$ npm install accepts
-```
-
-## API
-
-```js
-var accepts = require('accepts')
-```
-
-### accepts(req)
-
-Create a new `Accepts` object for the given `req`.
-
-#### .charset(charsets)
-
-Return the first accepted charset. If nothing in `charsets` is accepted,
-then `false` is returned.
-
-#### .charsets()
-
-Return the charsets that the request accepts, in the order of the client's
-preference (most preferred first).
-
-#### .encoding(encodings)
-
-Return the first accepted encoding. If nothing in `encodings` is accepted,
-then `false` is returned.
-
-#### .encodings()
-
-Return the encodings that the request accepts, in the order of the client's
-preference (most preferred first).
-
-#### .language(languages)
-
-Return the first accepted language. If nothing in `languages` is accepted,
-then `false` is returned.
-
-#### .languages()
-
-Return the languages that the request accepts, in the order of the client's
-preference (most preferred first).
-
-#### .type(types)
-
-Return the first accepted type (and it is returned as the same text as what
-appears in the `types` array). If nothing in `types` is accepted, then `false`
-is returned.
-
-The `types` array can contain full MIME types or file extensions. Any value
-that is not a full MIME types is passed to `require('mime-types').lookup`.
-
-#### .types()
-
-Return the types that the request accepts, in the order of the client's
-preference (most preferred first).
-
-## Examples
-
-### Simple type negotiation
-
-This simple example shows how to use `accepts` to return a different typed
-respond body based on what the client wants to accept. The server lists it's
-preferences in order and will get back the best match between the client and
-server.
-
-```js
-var accepts = require('accepts')
-var http = require('http')
-
-function app (req, res) {
-  var accept = accepts(req)
-
-  // the order of this list is significant; should be server preferred order
-  switch (accept.type(['json', 'html'])) {
-    case 'json':
-      res.setHeader('Content-Type', 'application/json')
-      res.write('{"hello":"world!"}')
-      break
-    case 'html':
-      res.setHeader('Content-Type', 'text/html')
-      res.write('<b>hello, world!</b>')
-      break
-    default:
-      // the fallback is text/plain, so no need to specify it above
-      res.setHeader('Content-Type', 'text/plain')
-      res.write('hello, world!')
-      break
-  }
-
-  res.end()
-}
-
-http.createServer(app).listen(3000)
-```
-
-You can test this out with the cURL program:
-```sh
-curl -I -H'Accept: text/html' http://localhost:3000/
-```
-
-## License
-
-[MIT](LICENSE)
-
-[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/accepts/master
-[coveralls-url]: https://coveralls.io/r/jshttp/accepts?branch=master
-[github-actions-ci-image]: https://badgen.net/github/checks/jshttp/accepts/master?label=ci
-[github-actions-ci-url]: https://github.com/jshttp/accepts/actions/workflows/ci.yml
-[node-version-image]: https://badgen.net/npm/node/accepts
-[node-version-url]: https://nodejs.org/en/download
-[npm-downloads-image]: https://badgen.net/npm/dm/accepts
-[npm-url]: https://npmjs.org/package/accepts
-[npm-version-image]: https://badgen.net/npm/v/accepts

node_modules/accepts/index.js

@@ -1,238 +0,0 @@
-/*!
- * accepts
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-var Negotiator = require('negotiator')
-var mime = require('mime-types')
-
-/**
- * Module exports.
- * @public
- */
-
-module.exports = Accepts
-
-/**
- * Create a new Accepts object for the given req.
- *
- * @param {object} req
- * @public
- */
-
-function Accepts (req) {
-  if (!(this instanceof Accepts)) {
-    return new Accepts(req)
-  }
-
-  this.headers = req.headers
-  this.negotiator = new Negotiator(req)
-}
-
-/**
- * Check if the given `type(s)` is acceptable, returning
- * the best match when true, otherwise `undefined`, in which
- * case you should respond with 406 "Not Acceptable".
- *
- * The `type` value may be a single mime type string
- * such as "application/json", the extension name
- * such as "json" or an array `["json", "html", "text/plain"]`. When a list
- * or array is given the _best_ match, if any is returned.
- *
- * Examples:
- *
- *     // Accept: text/html
- *     this.types('html');
- *     // => "html"
- *
- *     // Accept: text/*, application/json
- *     this.types('html');
- *     // => "html"
- *     this.types('text/html');
- *     // => "text/html"
- *     this.types('json', 'text');
- *     // => "json"
- *     this.types('application/json');
- *     // => "application/json"
- *
- *     // Accept: text/*, application/json
- *     this.types('image/png');
- *     this.types('png');
- *     // => undefined
- *
- *     // Accept: text/*;q=.5, application/json
- *     this.types(['html', 'json']);
- *     this.types('html', 'json');
- *     // => "json"
- *
- * @param {String|Array} types...
- * @return {String|Array|Boolean}
- * @public
- */
-
-Accepts.prototype.type =
-Accepts.prototype.types = function (types_) {
-  var types = types_
-
-  // support flattened arguments
-  if (types && !Array.isArray(types)) {
-    types = new Array(arguments.length)
-    for (var i = 0; i < types.length; i++) {
-      types[i] = arguments[i]
-    }
-  }
-
-  // no types, return all requested types
-  if (!types || types.length === 0) {
-    return this.negotiator.mediaTypes()
-  }
-
-  // no accept header, return first given type
-  if (!this.headers.accept) {
-    return types[0]
-  }
-
-  var mimes = types.map(extToMime)
-  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime))
-  var first = accepts[0]
-
-  return first
-    ? types[mimes.indexOf(first)]
-    : false
-}
-
-/**
- * Return accepted encodings or best fit based on `encodings`.
- *
- * Given `Accept-Encoding: gzip, deflate`
- * an array sorted by quality is returned:
- *
- *     ['gzip', 'deflate']
- *
- * @param {String|Array} encodings...
- * @return {String|Array}
- * @public
- */
-
-Accepts.prototype.encoding =
-Accepts.prototype.encodings = function (encodings_) {
-  var encodings = encodings_
-
-  // support flattened arguments
-  if (encodings && !Array.isArray(encodings)) {
-    encodings = new Array(arguments.length)
-    for (var i = 0; i < encodings.length; i++) {
-      encodings[i] = arguments[i]
-    }
-  }
-
-  // no encodings, return all requested encodings
-  if (!encodings || encodings.length === 0) {
-    return this.negotiator.encodings()
-  }
-
-  return this.negotiator.encodings(encodings)[0] || false
-}
-
-/**
- * Return accepted charsets or best fit based on `charsets`.
- *
- * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
- * an array sorted by quality is returned:
- *
- *     ['utf-8', 'utf-7', 'iso-8859-1']
- *
- * @param {String|Array} charsets...
- * @return {String|Array}
- * @public
- */
-
-Accepts.prototype.charset =
-Accepts.prototype.charsets = function (charsets_) {
-  var charsets = charsets_
-
-  // support flattened arguments
-  if (charsets && !Array.isArray(charsets)) {
-    charsets = new Array(arguments.length)
-    for (var i = 0; i < charsets.length; i++) {
-      charsets[i] = arguments[i]
-    }
-  }
-
-  // no charsets, return all requested charsets
-  if (!charsets || charsets.length === 0) {
-    return this.negotiator.charsets()
-  }
-
-  return this.negotiator.charsets(charsets)[0] || false
-}
-
-/**
- * Return accepted languages or best fit based on `langs`.
- *
- * Given `Accept-Language: en;q=0.8, es, pt`
- * an array sorted by quality is returned:
- *
- *     ['es', 'pt', 'en']
- *
- * @param {String|Array} langs...
- * @return {Array|String}
- * @public
- */
-
-Accepts.prototype.lang =
-Accepts.prototype.langs =
-Accepts.prototype.language =
-Accepts.prototype.languages = function (languages_) {
-  var languages = languages_
-
-  // support flattened arguments
-  if (languages && !Array.isArray(languages)) {
-    languages = new Array(arguments.length)
-    for (var i = 0; i < languages.length; i++) {
-      languages[i] = arguments[i]
-    }
-  }
-
-  // no languages, return all requested languages
-  if (!languages || languages.length === 0) {
-    return this.negotiator.languages()
-  }
-
-  return this.negotiator.languages(languages)[0] || false
-}
-
-/**
- * Convert extnames to mime.
- *
- * @param {String} type
- * @return {String}
- * @private
- */
-
-function extToMime (type) {
-  return type.indexOf('/') === -1
-    ? mime.lookup(type)
-    : type
-}
-
-/**
- * Check if mime is valid.
- *
- * @param {String} type
- * @return {String}
- * @private
- */
-
-function validMime (type) {
-  return typeof type === 'string'
-}

node_modules/accepts/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "accepts",
-  "description": "Higher-level content negotiation",
-  "version": "1.3.8",
-  "contributors": [
-    "Douglas Christopher Wilson <doug@somethingdoug.com>",
-    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
-  ],
-  "license": "MIT",
-  "repository": "jshttp/accepts",
-  "dependencies": {
-    "mime-types": "~2.1.34",
-    "negotiator": "0.6.3"
-  },
-  "devDependencies": {
-    "deep-equal": "1.0.1",
-    "eslint": "7.32.0",
-    "eslint-config-standard": "14.1.1",
-    "eslint-plugin-import": "2.25.4",
-    "eslint-plugin-markdown": "2.2.1",
-    "eslint-plugin-node": "11.1.0",
-    "eslint-plugin-promise": "4.3.1",
-    "eslint-plugin-standard": "4.1.0",
-    "mocha": "9.2.0",
-    "nyc": "15.1.0"
-  },
-  "files": [
-    "LICENSE",
-    "HISTORY.md",
-    "index.js"
-  ],
-  "engines": {
-    "node": ">= 0.6"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "test": "mocha --reporter spec --check-leaks --bail test/",
-    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
-    "test-cov": "nyc --reporter=html --reporter=text npm test"
-  },
-  "keywords": [
-    "content",
-    "negotiation",
-    "accept",
-    "accepts"
-  ]
-}

node_modules/acorn-dynamic-import/CHANGELOG.md

@@ -1,19 +0,0 @@
-# 2.0.2
-
-- Fixing parsing of `yield import()`.
-
-# 2.0.1
-
-- Removing unnecessary `in-publish` dependency.
-
-# 2.0.0
-
-- Updating acorn version to >= 4.
-
-# 1.0.1
-
-- Fixes for publishing the module.
-
-# 1.0.0
-
-- Initial release of plugin.

node_modules/acorn-dynamic-import/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016 Jordan Gensler
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

node_modules/acorn-dynamic-import/README.md

@@ -1,33 +0,0 @@
-# Dynamic import support in acorn
-
-This is plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-For more information, check out the [proposal repo](https://github.com/tc39/proposal-dynamic-import).
-
-## Usage
-
-You can use this module directly in order to get Acorn instance with plugin installed:
-
-```js
-import acorn from 'acorn-dynamic-import';
-// or...
-const acorn = require('acorn-dynamic-import').default;
-```
-
-Or you can use `inject.js` for injecting plugin into your own version of Acorn like this:
-
-```js
-const acorn = require('acorn-dynamic-import/lib/inject').default(require('./custom-acorn'));
-```
-
-Then, use the `plugins` option whenever you need to support dynamicImport while parsing:
-
-```js
-const ast = acorn.parse(code, {
-  plugins: { dynamicImport: true }
-});
-```
-
-## License
-
-This plugin is issued under the [MIT license](./LICENSE).

node_modules/acorn-dynamic-import/lib/index.js

@@ -1,17 +0,0 @@
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _acorn = require('acorn');
-
-var acorn = _interopRequireWildcard(_acorn);
-
-var _inject = require('./inject');
-
-var _inject2 = _interopRequireDefault(_inject);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
-
-exports['default'] = (0, _inject2['default'])(acorn);

node_modules/acorn-dynamic-import/lib/inject.js

@@ -1,70 +0,0 @@
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports['default'] = injectDynamicImport;
-/* eslint-disable no-underscore-dangle */
-
-function injectDynamicImport(acorn) {
-  var tt = acorn.tokTypes;
-
-  // NOTE: This allows `yield import()` to parse correctly.
-  tt._import.startsExpr = true;
-
-  function parseDynamicImport() {
-    var node = this.startNode();
-    this.next();
-    if (this.type !== tt.parenL) {
-      this.unexpected();
-    }
-    return this.finishNode(node, 'Import');
-  }
-
-  function peekNext() {
-    return this.input[this.pos];
-  }
-
-  // eslint-disable-next-line no-param-reassign
-  acorn.plugins.dynamicImport = function () {
-    function dynamicImportPlugin(instance) {
-      instance.extend('parseStatement', function (nextMethod) {
-        return function () {
-          function parseStatement() {
-            var node = this.startNode();
-            if (this.type === tt._import) {
-              var nextToken = peekNext.call(this);
-              if (nextToken === tt.parenL.label) {
-                var expr = this.parseExpression();
-                return this.parseExpressionStatement(node, expr);
-              }
-            }
-
-            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-              args[_key] = arguments[_key];
-            }
-
-            return nextMethod.apply(this, args);
-          }
-
-          return parseStatement;
-        }();
-      });
-
-      instance.extend('parseExprAtom', function (nextMethod) {
-        return function () {
-          function parseExprAtom(refDestructuringErrors) {
-            if (this.type === tt._import) {
-              return parseDynamicImport.call(this);
-            }
-            return nextMethod.call(this, refDestructuringErrors);
-          }
-
-          return parseExprAtom;
-        }();
-      });
-    }
-
-    return dynamicImportPlugin;
-  }();
-
-  return acorn;
-}

node_modules/acorn-dynamic-import/node_modules/.bin/acorn

@@ -1 +0,0 @@
-../acorn/bin/acorn

node_modules/acorn-dynamic-import/node_modules/acorn/.npmignore

@@ -1,10 +0,0 @@
-/.tern-port
-/test
-/local
-/rollup
-/bin/generate-identifier-regex.js
-/bin/update_authors.sh
-.editorconfig
-.gitattributes
-.tern-project
-.travis.yml

node_modules/acorn-dynamic-import/node_modules/acorn/AUTHORS

@@ -1,62 +0,0 @@
-List of Acorn contributors. Updated before every release.
-
-Adrian Rakovsky
-Alistair Braidwood
-Amila Welihinda
-Andres Suarez
-Angelo
-Aparajita Fishman
-Arian Stolwijk
-Artem Govorov
-Brandon Mills
-Charles Hughes
-Conrad Irwin
-Daniel Tschinder
-David Bonnet
-Domenico Matteo
-Forbes Lindesay
-Gilad Peleg
-impinball
-Ingvar Stepanyan
-Jackson Ray Hamilton
-Jesse McCarthy
-Jiaxing Wang
-Joel Kemp
-Johannes Herr
-Jordan Klassen
-Jürg Lehni
-Kai Cataldo
-keeyipchan
-Keheliya Gallaba
-Kevin Irish
-Kevin Kwok
-krator
-Marijn Haverbeke
-Martin Carlberg
-Mat Garcia
-Mathias Bynens
-Mathieu 'p01' Henri
-Matthew Bastien
-Max Schaefer
-Max Zerzouri
-Mihai Bazon
-Mike Rennie
-naoh
-Nicholas C. Zakas
-Nick Fitzgerald
-Olivier Thomann
-Oskar Schöldström
-Paul Harper
-Peter Rust
-PlNG
-Prayag Verma
-ReadmeCritic
-r-e-d
-Richard Gibson
-Rich Harris
-Sebastian McKenzie
-Simen Bekkhus
-Timothy Gu
-Toru Nagashima
-Wexpo Lyu
-zsjforcn

node_modules/acorn-dynamic-import/node_modules/acorn/CHANGELOG.md

@@ -1,286 +0,0 @@
-## 4.0.11 (2017-02-07)
-
-### Bug fixes
-
-Allow all forms of member expressions to be parenthesized as lvalue.
-
-## 4.0.10 (2017-02-07)
-
-### Bug fixes
-
-Don't expect semicolons after default-exported functions or classes,
-even when they are expressions.
-
-Check for use of `'use strict'` directives in non-simple parameter
-functions, even when already in strict mode.
-
-## 4.0.9 (2017-02-06)
-
-### Bug fixes
-
-Fix incorrect error raised for parenthesized simple assignment
-targets, so that `(x) = 1` parses again.
-
-## 4.0.8 (2017-02-03)
-
-### Bug fixes
-
-Solve spurious parenthesized pattern errors by temporarily erring on
-the side of accepting programs that our delayed errors don't handle
-correctly yet.
-
-## 4.0.7 (2017-02-02)
-
-### Bug fixes
-
-Accept invalidly rejected code like `(x).y = 2` again.
-
-Don't raise an error when a function _inside_ strict code has a
-non-simple parameter list.
-
-## 4.0.6 (2017-02-02)
-
-### Bug fixes
-
-Fix exponential behavior (manifesting itself as a complete hang for
-even relatively small source files) introduced by the new 'use strict'
-check.
-
-## 4.0.5 (2017-02-02)
-
-### Bug fixes
-
-Disallow parenthesized pattern expressions.
-
-Allow keywords as export names.
-
-Don't allow the `async` keyword to be parenthesized.
-
-Properly raise an error when a keyword contains a character escape.
-
-Allow `"use strict"` to appear after other string literal expressions.
-
-Disallow labeled declarations.
-
-## 4.0.4 (2016-12-19)
-
-### Bug fixes
-
-Fix issue with loading acorn_loose.js with an AMD loader.
-
-Fix crash when `export` was followed by a keyword that can't be
-exported.
-
-## 4.0.3 (2016-08-16)
-
-### Bug fixes
-
-Allow regular function declarations inside single-statement `if`
-branches in loose mode. Forbid them entirely in strict mode.
-
-Properly parse properties named `async` in ES2017 mode.
-
-Fix bug where reserved words were broken in ES2017 mode.
-
-## 4.0.2 (2016-08-11)
-
-### Bug fixes
-
-Don't ignore period or 'e' characters after octal numbers.
-
-Fix broken parsing for call expressions in default parameter values
-of arrow functions.
-
-## 4.0.1 (2016-08-08)
-
-### Bug fixes
-
-Fix false positives in duplicated export name errors.
-
-## 4.0.0 (2016-08-07)
-
-### Breaking changes
-
-The default `ecmaVersion` option value is now 7.
-
-A number of internal method signatures changed, so plugins might need
-to be updated.
-
-### Bug fixes
-
-The parser now raises errors on duplicated export names.
-
-`arguments` and `eval` can now be used in shorthand properties.
-
-Duplicate parameter names in non-simple argument lists now always
-produce an error.
-
-### New features
-
-The `ecmaVersion` option now also accepts year-style version numbers
-(2015, etc).
-
-Support for `async`/`await` syntax when `ecmaVersion` is >= 8.
-
-Support for trailing commas in call expressions when `ecmaVersion`
-is >= 8.
-
-## 3.3.0 (2016-07-25)
-
-### Bug fixes
-
-Fix bug in tokenizing of regexp operator after a function declaration.
-
-Fix parser crash when parsing an array pattern with a hole.
-
-### New features
-
-Implement check against complex argument lists in functions that
-enable strict mode in ES7.
-
-## 3.2.0 (2016-06-07)
-
-### Bug fixes
-
-Improve handling of lack of unicode regexp support in host
-environment.
-
-Properly reject shorthand properties whose name is a keyword.
-
-Don't crash when the loose parser is called without options object.
-
-### New features
-
-Visitors created with `visit.make` now have their base as _prototype_,
-rather than copying properties into a fresh object.
-
-Make it possible to use `visit.ancestor` with a walk state.
-
-## 3.1.0 (2016-04-18)
-
-### Bug fixes
-
-Fix issue where the loose parser created invalid TemplateElement nodes
-for unclosed template literals.
-
-Properly tokenize the division operator directly after a function
-expression.
-
-Allow trailing comma in destructuring arrays.
-
-### New features
-
-The walker now allows defining handlers for `CatchClause` nodes.
-
-## 3.0.4 (2016-02-25)
-
-### Fixes
-
-Allow update expressions as left-hand-side of the ES7 exponential
-operator.
-
-## 3.0.2 (2016-02-10)
-
-### Fixes
-
-Fix bug that accidentally made `undefined` a reserved word when
-parsing ES7.
-
-## 3.0.0 (2016-02-10)
-
-### Breaking changes
-
-The default value of the `ecmaVersion` option is now 6 (used to be 5).
-
-Support for comprehension syntax (which was dropped from the draft
-spec) has been removed.
-
-### Fixes
-
-`let` and `yield` are now “contextual keywords”, meaning you can
-mostly use them as identifiers in ES5 non-strict code.
-
-A parenthesized class or function expression after `export default` is
-now parsed correctly.
-
-### New features
-
-When `ecmaVersion` is set to 7, Acorn will parse the exponentiation
-operator (`**`).
-
-The identifier character ranges are now based on Unicode 8.0.0.
-
-Plugins can now override the `raiseRecoverable` method to override the
-way non-critical errors are handled.
-
-## 2.7.0 (2016-01-04)
-
-### Fixes
-
-Stop allowing rest parameters in setters.
-
-Make sure the loose parser always attaches a `local` property to
-`ImportNamespaceSpecifier` nodes.
-
-Disallow `y` rexexp flag in ES5.
-
-Disallow `\00` and `\000` escapes in strict mode.
-
-Raise an error when an import name is a reserved word.
-
-## 2.6.4 (2015-11-12)
-
-### Fixes
-
-Fix crash in loose parser when parsing invalid object pattern.
-
-### New features
-
-Support plugins in the loose parser.
-
-## 2.6.2 (2015-11-10)
-
-### Fixes
-
-Don't crash when no options object is passed.
-
-## 2.6.0 (2015-11-09)
-
-### Fixes
-
-Add `await` as a reserved word in module sources.
-
-Disallow `yield` in a parameter default value for a generator.
-
-Forbid using a comma after a rest pattern in an array destructuring.
-
-### New features
-
-Support parsing stdin in command-line tool.
-
-## 2.5.2 (2015-10-27)
-
-### Fixes
-
-Fix bug where the walker walked an exported `let` statement as an
-expression.
-
-## 2.5.0 (2015-10-27)
-
-### Fixes
-
-Fix tokenizer support in the command-line tool.
-
-In the loose parser, don't allow non-string-literals as import
-sources.
-
-Stop allowing `new.target` outside of functions.
-
-Remove legacy `guard` and `guardedHandler` properties from try nodes.
-
-Stop allowing multiple `__proto__` properties on an object literal in
-strict mode.
-
-Don't allow rest parameters to be non-identifier patterns.
-
-Check for duplicate paramter names in arrow functions.

node_modules/acorn-dynamic-import/node_modules/acorn/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2012-2016 by various contributors (see AUTHORS)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

node_modules/acorn-dynamic-import/node_modules/acorn/README.md

@@ -1,409 +0,0 @@
-# Acorn
-
-[![Build Status](https://travis-ci.org/ternjs/acorn.svg?branch=master)](https://travis-ci.org/ternjs/acorn)
-[![NPM version](https://img.shields.io/npm/v/acorn.svg)](https://www.npmjs.com/package/acorn)
-[![CDNJS](https://img.shields.io/cdnjs/v/acorn.svg)](https://cdnjs.com/libraries/acorn)  
-[Author funding status: ![maintainer happiness](https://marijnhaverbeke.nl/fund/status_s.png?force)](https://marijnhaverbeke.nl/fund/)
-
-A tiny, fast JavaScript parser, written completely in JavaScript.
-
-## Community
-
-Acorn is open source software released under an
-[MIT license](https://github.com/ternjs/acorn/blob/master/LICENSE).
-
-You are welcome to
-[report bugs](https://github.com/ternjs/acorn/issues) or create pull
-requests on [github](https://github.com/ternjs/acorn). For questions
-and discussion, please use the
-[Tern discussion forum](https://discuss.ternjs.net).
-
-## Installation
-
-The easiest way to install acorn is with [`npm`][npm].
-
-[npm]: https://www.npmjs.com/
-
-```sh
-npm install acorn
-```
-
-Alternately, download the source.
-
-```sh
-git clone https://github.com/ternjs/acorn.git
-```
-
-## Components
-
-When run in a CommonJS (node.js) or AMD environment, exported values
-appear in the interfaces exposed by the individual files, as usual.
-When loaded in the browser (Acorn works in any JS-enabled browser more
-recent than IE5) without any kind of module management, a single
-global object `acorn` will be defined, and all the exported properties
-will be added to that.
-
-### Main parser
-
-This is implemented in `dist/acorn.js`, and is what you get when you
-`require("acorn")` in node.js.
-
-**parse**`(input, options)` is used to parse a JavaScript program.
-The `input` parameter is a string, `options` can be undefined or an
-object setting some of the options listed below. The return value will
-be an abstract syntax tree object as specified by the
-[ESTree spec][estree].
-
-When  encountering   a  syntax   error,  the   parser  will   raise  a
-`SyntaxError` object with a meaningful  message. The error object will
-have a `pos` property that indicates the character offset at which the
-error occurred,  and a `loc`  object that contains a  `{line, column}`
-object referring to that same position.
-
-[estree]: https://github.com/estree/estree
-
-- **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
-  either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support for strict
-  mode, the set of reserved words, and support for new syntax features.
-  Default is 7.
-
-  **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being
-  implemented by Acorn.
-
-- **sourceType**: Indicate the mode the code should be parsed in. Can be
-  either `"script"` or `"module"`. This influences global strict mode
-  and parsing of `import` and `export` declarations.
-
-- **onInsertedSemicolon**: If given a callback, that callback will be
-  called whenever a missing semicolon is inserted by the parser. The
-  callback will be given the character offset of the point where the
-  semicolon is inserted as argument, and if `locations` is on, also a
-  `{line, column}` object representing this position.
-
-- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
-  commas.
-
-- **allowReserved**: If `false`, using a reserved word will generate
-  an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher
-  versions. When given the value `"never"`, reserved words and
-  keywords can also not be used as property names (as in Internet
-  Explorer's old parser).
-
-- **allowReturnOutsideFunction**: By default, a return statement at
-  the top level raises an error. Set this to `true` to accept such
-  code.
-
-- **allowImportExportEverywhere**: By default, `import` and `export`
-  declarations can only appear at a program's top level. Setting this
-  option to `true` allows them anywhere where a statement is allowed.
-
-- **allowHashBang**: When this is enabled (off by default), if the
-  code starts with the characters `#!` (as in a shellscript), the
-  first line will be treated as a comment.
-
-- **locations**: When `true`, each node has a `loc` object attached
-  with `start` and `end` subobjects, each of which contains the
-  one-based line and zero-based column numbers in `{line, column}`
-  form. Default is `false`.
-
-- **onToken**: If a function is passed for this option, each found
-  token will be passed in same format as tokens returned from
-  `tokenizer().getToken()`.
-
-  If array is passed, each found token is pushed to it.
-
-  Note that you are not allowed to call the parser from the
-  callback—that will corrupt its internal state.
-
-- **onComment**: If a function is passed for this option, whenever a
-  comment is encountered the function will be called with the
-  following parameters:
-
-  - `block`: `true` if the comment is a block comment, false if it
-    is a line comment.
-  - `text`: The content of the comment.
-  - `start`: Character offset of the start of the comment.
-  - `end`: Character offset of the end of the comment.
-
-  When the `locations` options is on, the `{line, column}` locations
-  of the comment’s start and end are passed as two additional
-  parameters.
-
-  If array is passed for this option, each found comment is pushed
-  to it as object in Esprima format:
-
-  ```javascript
-  {
-    "type": "Line" | "Block",
-    "value": "comment text",
-    "start": Number,
-    "end": Number,
-    // If `locations` option is on:
-    "loc": {
-      "start": {line: Number, column: Number}
-      "end": {line: Number, column: Number}
-    },
-    // If `ranges` option is on:
-    "range": [Number, Number]
-  }
-  ```
-
-  Note that you are not allowed to call the parser from the
-  callback—that will corrupt its internal state.
-
-- **ranges**: Nodes have their start and end characters offsets
-  recorded in `start` and `end` properties (directly on the node,
-  rather than the `loc` object, which holds line/column data. To also
-  add a [semi-standardized][range] `range` property holding a
-  `[start, end]` array with the same numbers, set the `ranges` option
-  to `true`.
-
-- **program**: It is possible to parse multiple files into a single
-  AST by passing the tree produced by parsing the first file as the
-  `program` option in subsequent parses. This will add the toplevel
-  forms of the parsed file to the "Program" (top) node of an existing
-  parse tree.
-
-- **sourceFile**: When the `locations` option is `true`, you can pass
-  this option to add a `source` attribute in every node’s `loc`
-  object. Note that the contents of this option are not examined or
-  processed in any way; you are free to use whatever format you
-  choose.
-
-- **directSourceFile**: Like `sourceFile`, but a `sourceFile` property
-  will be added (regardless of the `location` option) directly to the
-  nodes, rather than the `loc` object.
-
-- **preserveParens**: If this option is `true`, parenthesized expressions
-  are represented by (non-standard) `ParenthesizedExpression` nodes
-  that have a single `expression` property containing the expression
-  inside parentheses.
-
-[range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-
-**parseExpressionAt**`(input, offset, options)` will parse a single
-expression in a string, and return its AST. It will not complain if
-there is more of the string left after the expression.
-
-**getLineInfo**`(input, offset)` can be used to get a `{line,
-column}` object for a given program string and character offset.
-
-**tokenizer**`(input, options)` returns an object with a `getToken`
-method that can be called repeatedly to get the next token, a `{start,
-end, type, value}` object (with added `loc` property when the
-`locations` option is enabled and `range` property when the `ranges`
-option is enabled). When the token's type is `tokTypes.eof`, you
-should stop calling the method, since it will keep returning that same
-token forever.
-
-In ES6 environment, returned result can be used as any other
-protocol-compliant iterable:
-
-```javascript
-for (let token of acorn.tokenizer(str)) {
-  // iterate over the tokens
-}
-
-// transform code to array of tokens:
-var tokens = [...acorn.tokenizer(str)];
-```
-
-**tokTypes** holds an object mapping names to the token type objects
-that end up in the `type` properties of tokens.
-
-#### Note on using with [Escodegen][escodegen]
-
-Escodegen supports generating comments from AST, attached in
-Esprima-specific format. In order to simulate same format in
-Acorn, consider following example:
-
-```javascript
-var comments = [], tokens = [];
-
-var ast = acorn.parse('var x = 42; // answer', {
-	// collect ranges for each node
-	ranges: true,
-	// collect comments in Esprima's format
-	onComment: comments,
-	// collect token ranges
-	onToken: tokens
-});
-
-// attach comments using collected information
-escodegen.attachComments(ast, comments, tokens);
-
-// generate code
-console.log(escodegen.generate(ast, {comment: true}));
-// > 'var x = 42;    // answer'
-```
-
-[escodegen]: https://github.com/estools/escodegen
-
-### dist/acorn_loose.js ###
-
-This file implements an error-tolerant parser. It exposes a single
-function. The loose parser is accessible in node.js via `require("acorn/dist/acorn_loose")`.
-
-**parse_dammit**`(input, options)` takes the same arguments and
-returns the same syntax tree as the `parse` function in `acorn.js`,
-but never raises an error, and will do its best to parse syntactically
-invalid code in as meaningful a way as it can. It'll insert identifier
-nodes with name `"✖"` as placeholders in places where it can't make
-sense of the input. Depends on `acorn.js`, because it uses the same
-tokenizer.
-
-### dist/walk.js ###
-
-Implements an abstract syntax tree walker. Will store its interface in
-`acorn.walk` when loaded without a module system.
-
-**simple**`(node, visitors, base, state)` does a 'simple' walk over
-a tree. `node` should be the AST node to walk, and `visitors` an
-object with properties whose names correspond to node types in the
-[ESTree spec][estree]. The properties should contain functions
-that will be called with the node object and, if applicable the state
-at that point. The last two arguments are optional. `base` is a walker
-algorithm, and `state` is a start state. The default walker will
-simply visit all statements and expressions and not produce a
-meaningful state. (An example of a use of state is to track scope at
-each point in the tree.)
-
-**ancestor**`(node, visitors, base, state)` does a 'simple' walk over
-a tree, building up an array of ancestor nodes (including the current node)
-and passing the array to the callbacks as a third parameter.
-
-**recursive**`(node, state, functions, base)` does a 'recursive'
-walk, where the walker functions are responsible for continuing the
-walk on the child nodes of their target node. `state` is the start
-state, and `functions` should contain an object that maps node types
-to walker functions. Such functions are called with `(node, state, c)`
-arguments, and can cause the walk to continue on a sub-node by calling
-the `c` argument on it with `(node, state)` arguments. The optional
-`base` argument provides the fallback walker functions for node types
-that aren't handled in the `functions` object. If not given, the
-default walkers will be used.
-
-**make**`(functions, base)` builds a new walker object by using the
-walker functions in `functions` and filling in the missing ones by
-taking defaults from `base`.
-
-**findNodeAt**`(node, start, end, test, base, state)` tries to
-locate a node in a tree at the given start and/or end offsets, which
-satisfies the predicate `test`. `start` and `end` can be either `null`
-(as wildcard) or a number. `test` may be a string (indicating a node
-type) or a function that takes `(nodeType, node)` arguments and
-returns a boolean indicating whether this node is interesting. `base`
-and `state` are optional, and can be used to specify a custom walker.
-Nodes are tested from inner to outer, so if two nodes match the
-boundaries, the inner one will be preferred.
-
-**findNodeAround**`(node, pos, test, base, state)` is a lot like
-`findNodeAt`, but will match any node that exists 'around' (spanning)
-the given position.
-
-**findNodeAfter**`(node, pos, test, base, state)` is similar to
-`findNodeAround`, but will match all nodes *after* the given position
-(testing outer nodes before inner nodes).
-
-## Command line interface
-
-The `bin/acorn` utility can be used to parse a file from the command
-line. It accepts as arguments its input file and the following
-options:
-
-- `--ecma3|--ecma5|--ecma6|--ecma7`: Sets the ECMAScript version to parse. Default is
-  version 5.
-
-- `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise.
-
-- `--locations`: Attaches a "loc" object to each node with "start" and
-  "end" subobjects, each of which contains the one-based line and
-  zero-based column numbers in `{line, column}` form.
-
-- `--allow-hash-bang`: If the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment.
-
-- `--compact`: No whitespace is used in the AST output.
-
-- `--silent`: Do not output the AST, just return the exit status.
-
-- `--help`: Print the usage information and quit.
-
-The utility spits out the syntax tree as JSON data.
-
-## Build system
-
-Acorn is written in ECMAScript 6, as a set of small modules, in the
-project's `src` directory, and compiled down to bigger ECMAScript 3
-files in `dist` using [Browserify](http://browserify.org) and
-[Babel](http://babeljs.io/). If you are already using Babel, you can
-consider including the modules directly.
-
-The command-line test runner (`npm test`) uses the ES6 modules. The
-browser-based test page (`test/index.html`) uses the compiled modules.
-The `bin/build-acorn.js` script builds the latter from the former.
-
-If you are working on Acorn, you'll probably want to try the code out
-directly, without an intermediate build step. In your scripts, you can
-register the Babel require shim like this:
-
-    require("babel-core/register")
-
-That will allow you to directly `require` the ES6 modules.
-
-## Plugins
-
-Acorn is designed support allow plugins which, within reasonable
-bounds, redefine the way the parser works. Plugins can add new token
-types and new tokenizer contexts (if necessary), and extend methods in
-the parser object. This is not a clean, elegant API—using it requires
-an understanding of Acorn's internals, and plugins are likely to break
-whenever those internals are significantly changed. But still, it is
-_possible_, in this way, to create parsers for JavaScript dialects
-without forking all of Acorn. And in principle it is even possible to
-combine such plugins, so that if you have, for example, a plugin for
-parsing types and a plugin for parsing JSX-style XML literals, you
-could load them both and parse code with both JSX tags and types.
-
-A plugin should register itself by adding a property to
-`acorn.plugins`, which holds a function. Calling `acorn.parse`, a
-`plugins` option can be passed, holding an object mapping plugin names
-to configuration values (or just `true` for plugins that don't take
-options). After the parser object has been created, the initialization
-functions for the chosen plugins are called with `(parser,
-configValue)` arguments. They are expected to use the `parser.extend`
-method to extend parser methods. For example, the `readToken` method
-could be extended like this:
-
-```javascript
-parser.extend("readToken", function(nextMethod) {
-  return function(code) {
-    console.log("Reading a token!")
-    return nextMethod.call(this, code)
-  }
-})
-```
-
-The `nextMethod` argument passed to `extend`'s second argument is the
-previous value of this method, and should usually be called through to
-whenever the extended method does not handle the call itself.
-
-Similarly, the loose parser allows plugins to register themselves via
-`acorn.pluginsLoose`.  The extension mechanism is the same as for the
-normal parser:
-
-```javascript
-looseParser.extend("readToken", function(nextMethod) {
-  return function() {
-    console.log("Reading a token in the loose parser!")
-    return nextMethod.call(this)
-  }
-})
-```
-
-### Existing plugins
-
- - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx)
- - [`acorn-es7-plugin`](https://github.com/MatAtBread/acorn-es7-plugin/): Parse [async/await syntax proposal](https://github.com/tc39/ecmascript-asyncawait)
- - [`acorn-object-spread`](https://github.com/UXtemple/acorn-object-spread): Parse [object spread syntax proposal](https://github.com/sebmarkbage/ecmascript-rest-spread)
- - [`acorn-es7`](https://www.npmjs.com/package/acorn-es7): Parse [decorator syntax proposal](https://github.com/wycats/javascript-decorators)
- - [`acorn-objj`](https://www.npmjs.com/package/acorn-objj): [Objective-J](http://www.cappuccino-project.org/learn/objective-j.html) language parser built as Acorn plugin

node_modules/acorn-dynamic-import/node_modules/acorn/bin/acorn

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

node_modules/acorn-dynamic-import/node_modules/acorn/dist/walk.es.js

@@ -1,342 +0,0 @@
-// AST walker module for Mozilla Parser API compatible trees
-
-// A simple walk is one where you simply specify callbacks to be
-// called on specific nodes. The last two arguments are optional. A
-// simple use would be
-//
-//     walk.simple(myTree, {
-//         Expression: function(node) { ... }
-//     });
-//
-// to do something with all expressions. All Parser API node types
-// can be used to identify node types, as well as Expression,
-// Statement, and ScopeBody, which denote categories of nodes.
-//
-// The base argument can be used to pass a custom (recursive)
-// walker, and state can be used to give this walked an initial
-// state.
-
-function simple(node, visitors, base, state, override) {
-  if (!base) base = exports.base
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    base[type](node, st, c)
-    if (found) found(node, st)
-  })(node, state, override)
-}
-
-// An ancestor walk keeps an array of ancestor nodes (including the
-// current node) and passes them to the callback as third parameter
-// (and also as state parameter when no other state is present).
-function ancestor(node, visitors, base, state) {
-  if (!base) base = exports.base
-  var ancestors = []
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    var isNew = node != ancestors[ancestors.length - 1]
-    if (isNew) ancestors.push(node)
-    base[type](node, st, c)
-    if (found) found(node, st || ancestors, ancestors)
-    if (isNew) ancestors.pop()
-  })(node, state)
-}
-
-// A recursive walk is one where your functions override the default
-// walkers. They can modify and replace the state parameter that's
-// threaded through the walk, and can opt how and whether to walk
-// their child nodes (by calling their third argument on these
-// nodes).
-function recursive(node, state, funcs, base, override) {
-  var visitor = funcs ? exports.make(funcs, base) : base
-  ;(function c(node, st, override) {
-    visitor[override || node.type](node, st, c)
-  })(node, state, override)
-}
-
-function makeTest(test) {
-  if (typeof test == "string")
-    return function (type) { return type == test; }
-  else if (!test)
-    return function () { return true; }
-  else
-    return test
-}
-
-var Found = function Found(node, state) { this.node = node; this.state = state };
-
-// Find a node with a given start, end, and type (all are optional,
-// null can be used as wildcard). Returns a {node, state} object, or
-// undefined when it doesn't find a matching node.
-function findNodeAt(node, start, end, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      var type = override || node.type
-      if ((start == null || node.start <= start) &&
-          (end == null || node.end >= end))
-        base[type](node, st, c)
-      if ((start == null || node.start == start) &&
-          (end == null || node.end == end) &&
-          test(type, node))
-        throw new Found(node, st)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the innermost node of a given type that contains the given
-// position. Interface similar to findNodeAt.
-function findNodeAround(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      var type = override || node.type
-      if (node.start > pos || node.end < pos) return
-      base[type](node, st, c)
-      if (test(type, node)) throw new Found(node, st)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the outermost matching node after a given position.
-function findNodeAfter(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      if (node.end < pos) return
-      var type = override || node.type
-      if (node.start >= pos && test(type, node)) throw new Found(node, st)
-      base[type](node, st, c)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the outermost matching node before a given position.
-function findNodeBefore(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  var max
-  ;(function c(node, st, override) {
-    if (node.start > pos) return
-    var type = override || node.type
-    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
-      max = new Found(node, st)
-    base[type](node, st, c)
-  })(node, state)
-  return max
-}
-
-// Fallback to an Object.create polyfill for older environments.
-var create = Object.create || function(proto) {
-  function Ctor() {}
-  Ctor.prototype = proto
-  return new Ctor
-}
-
-// Used to create a custom walker. Will fill in all missing node
-// type properties with the defaults.
-function make(funcs, base) {
-  if (!base) base = exports.base
-  var visitor = create(base)
-  for (var type in funcs) visitor[type] = funcs[type]
-  return visitor
-}
-
-function skipThrough(node, st, c) { c(node, st) }
-function ignore(_node, _st, _c) {}
-
-// Node walkers.
-
-var base = {}
-
-base.Program = base.BlockStatement = function (node, st, c) {
-  for (var i = 0; i < node.body.length; ++i)
-    c(node.body[i], st, "Statement")
-}
-base.Statement = skipThrough
-base.EmptyStatement = ignore
-base.ExpressionStatement = base.ParenthesizedExpression =
-  function (node, st, c) { return c(node.expression, st, "Expression"); }
-base.IfStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Statement")
-  if (node.alternate) c(node.alternate, st, "Statement")
-}
-base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }
-base.BreakStatement = base.ContinueStatement = ignore
-base.WithStatement = function (node, st, c) {
-  c(node.object, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.SwitchStatement = function (node, st, c) {
-  c(node.discriminant, st, "Expression")
-  for (var i = 0; i < node.cases.length; ++i) {
-    var cs = node.cases[i]
-    if (cs.test) c(cs.test, st, "Expression")
-    for (var j = 0; j < cs.consequent.length; ++j)
-      c(cs.consequent[j], st, "Statement")
-  }
-}
-base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
-  if (node.argument) c(node.argument, st, "Expression")
-}
-base.ThrowStatement = base.SpreadElement =
-  function (node, st, c) { return c(node.argument, st, "Expression"); }
-base.TryStatement = function (node, st, c) {
-  c(node.block, st, "Statement")
-  if (node.handler) c(node.handler, st)
-  if (node.finalizer) c(node.finalizer, st, "Statement")
-}
-base.CatchClause = function (node, st, c) {
-  c(node.param, st, "Pattern")
-  c(node.body, st, "ScopeBody")
-}
-base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForStatement = function (node, st, c) {
-  if (node.init) c(node.init, st, "ForInit")
-  if (node.test) c(node.test, st, "Expression")
-  if (node.update) c(node.update, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForInStatement = base.ForOfStatement = function (node, st, c) {
-  c(node.left, st, "ForInit")
-  c(node.right, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForInit = function (node, st, c) {
-  if (node.type == "VariableDeclaration") c(node, st)
-  else c(node, st, "Expression")
-}
-base.DebuggerStatement = ignore
-
-base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }
-base.VariableDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.declarations.length; ++i)
-    c(node.declarations[i], st)
-}
-base.VariableDeclarator = function (node, st, c) {
-  c(node.id, st, "Pattern")
-  if (node.init) c(node.init, st, "Expression")
-}
-
-base.Function = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  for (var i = 0; i < node.params.length; i++)
-    c(node.params[i], st, "Pattern")
-  c(node.body, st, node.expression ? "ScopeExpression" : "ScopeBody")
-}
-// FIXME drop these node types in next major version
-// (They are awkward, and in ES6 every block can be a scope.)
-base.ScopeBody = function (node, st, c) { return c(node, st, "Statement"); }
-base.ScopeExpression = function (node, st, c) { return c(node, st, "Expression"); }
-
-base.Pattern = function (node, st, c) {
-  if (node.type == "Identifier")
-    c(node, st, "VariablePattern")
-  else if (node.type == "MemberExpression")
-    c(node, st, "MemberPattern")
-  else
-    c(node, st)
-}
-base.VariablePattern = ignore
-base.MemberPattern = skipThrough
-base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }
-base.ArrayPattern =  function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Pattern")
-  }
-}
-base.ObjectPattern = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i].value, st, "Pattern")
-}
-
-base.Expression = skipThrough
-base.ThisExpression = base.Super = base.MetaProperty = ignore
-base.ArrayExpression = function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Expression")
-  }
-}
-base.ObjectExpression = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i], st)
-}
-base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration
-base.SequenceExpression = base.TemplateLiteral = function (node, st, c) {
-  for (var i = 0; i < node.expressions.length; ++i)
-    c(node.expressions[i], st, "Expression")
-}
-base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
-  c(node.argument, st, "Expression")
-}
-base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
-  c(node.left, st, "Expression")
-  c(node.right, st, "Expression")
-}
-base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
-  c(node.left, st, "Pattern")
-  c(node.right, st, "Expression")
-}
-base.ConditionalExpression = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Expression")
-  c(node.alternate, st, "Expression")
-}
-base.NewExpression = base.CallExpression = function (node, st, c) {
-  c(node.callee, st, "Expression")
-  if (node.arguments) for (var i = 0; i < node.arguments.length; ++i)
-    c(node.arguments[i], st, "Expression")
-}
-base.MemberExpression = function (node, st, c) {
-  c(node.object, st, "Expression")
-  if (node.computed) c(node.property, st, "Expression")
-}
-base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
-  if (node.declaration)
-    c(node.declaration, st, node.type == "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression")
-  if (node.source) c(node.source, st, "Expression")
-}
-base.ExportAllDeclaration = function (node, st, c) {
-  c(node.source, st, "Expression")
-}
-base.ImportDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.specifiers.length; i++)
-    c(node.specifiers[i], st)
-  c(node.source, st, "Expression")
-}
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore
-
-base.TaggedTemplateExpression = function (node, st, c) {
-  c(node.tag, st, "Expression")
-  c(node.quasi, st)
-}
-base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }
-base.Class = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  if (node.superClass) c(node.superClass, st, "Expression")
-  for (var i = 0; i < node.body.body.length; i++)
-    c(node.body.body[i], st)
-}
-base.MethodDefinition = base.Property = function (node, st, c) {
-  if (node.computed) c(node.key, st, "Expression")
-  c(node.value, st, "Expression")
-}
-
-export { simple, ancestor, recursive, findNodeAt, findNodeAround, findNodeAfter, findNodeBefore, make, base };

node_modules/acorn-dynamic-import/node_modules/acorn/dist/walk.js

@@ -1,360 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (factory((global.acorn = global.acorn || {}, global.acorn.walk = global.acorn.walk || {})));
-}(this, (function (exports) { 'use strict';
-
-// AST walker module for Mozilla Parser API compatible trees
-
-// A simple walk is one where you simply specify callbacks to be
-// called on specific nodes. The last two arguments are optional. A
-// simple use would be
-//
-//     walk.simple(myTree, {
-//         Expression: function(node) { ... }
-//     });
-//
-// to do something with all expressions. All Parser API node types
-// can be used to identify node types, as well as Expression,
-// Statement, and ScopeBody, which denote categories of nodes.
-//
-// The base argument can be used to pass a custom (recursive)
-// walker, and state can be used to give this walked an initial
-// state.
-
-function simple(node, visitors, base, state, override) {
-  if (!base) base = exports.base
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    base[type](node, st, c)
-    if (found) found(node, st)
-  })(node, state, override)
-}
-
-// An ancestor walk keeps an array of ancestor nodes (including the
-// current node) and passes them to the callback as third parameter
-// (and also as state parameter when no other state is present).
-function ancestor(node, visitors, base, state) {
-  if (!base) base = exports.base
-  var ancestors = []
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    var isNew = node != ancestors[ancestors.length - 1]
-    if (isNew) ancestors.push(node)
-    base[type](node, st, c)
-    if (found) found(node, st || ancestors, ancestors)
-    if (isNew) ancestors.pop()
-  })(node, state)
-}
-
-// A recursive walk is one where your functions override the default
-// walkers. They can modify and replace the state parameter that's
-// threaded through the walk, and can opt how and whether to walk
-// their child nodes (by calling their third argument on these
-// nodes).
-function recursive(node, state, funcs, base, override) {
-  var visitor = funcs ? exports.make(funcs, base) : base
-  ;(function c(node, st, override) {
-    visitor[override || node.type](node, st, c)
-  })(node, state, override)
-}
-
-function makeTest(test) {
-  if (typeof test == "string")
-    return function (type) { return type == test; }
-  else if (!test)
-    return function () { return true; }
-  else
-    return test
-}
-
-var Found = function Found(node, state) { this.node = node; this.state = state };
-
-// Find a node with a given start, end, and type (all are optional,
-// null can be used as wildcard). Returns a {node, state} object, or
-// undefined when it doesn't find a matching node.
-function findNodeAt(node, start, end, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      var type = override || node.type
-      if ((start == null || node.start <= start) &&
-          (end == null || node.end >= end))
-        base[type](node, st, c)
-      if ((start == null || node.start == start) &&
-          (end == null || node.end == end) &&
-          test(type, node))
-        throw new Found(node, st)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the innermost node of a given type that contains the given
-// position. Interface similar to findNodeAt.
-function findNodeAround(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      var type = override || node.type
-      if (node.start > pos || node.end < pos) return
-      base[type](node, st, c)
-      if (test(type, node)) throw new Found(node, st)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the outermost matching node after a given position.
-function findNodeAfter(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  try {
-    ;(function c(node, st, override) {
-      if (node.end < pos) return
-      var type = override || node.type
-      if (node.start >= pos && test(type, node)) throw new Found(node, st)
-      base[type](node, st, c)
-    })(node, state)
-  } catch (e) {
-    if (e instanceof Found) return e
-    throw e
-  }
-}
-
-// Find the outermost matching node before a given position.
-function findNodeBefore(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  var max
-  ;(function c(node, st, override) {
-    if (node.start > pos) return
-    var type = override || node.type
-    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
-      max = new Found(node, st)
-    base[type](node, st, c)
-  })(node, state)
-  return max
-}
-
-// Fallback to an Object.create polyfill for older environments.
-var create = Object.create || function(proto) {
-  function Ctor() {}
-  Ctor.prototype = proto
-  return new Ctor
-}
-
-// Used to create a custom walker. Will fill in all missing node
-// type properties with the defaults.
-function make(funcs, base) {
-  if (!base) base = exports.base
-  var visitor = create(base)
-  for (var type in funcs) visitor[type] = funcs[type]
-  return visitor
-}
-
-function skipThrough(node, st, c) { c(node, st) }
-function ignore(_node, _st, _c) {}
-
-// Node walkers.
-
-var base = {}
-
-base.Program = base.BlockStatement = function (node, st, c) {
-  for (var i = 0; i < node.body.length; ++i)
-    c(node.body[i], st, "Statement")
-}
-base.Statement = skipThrough
-base.EmptyStatement = ignore
-base.ExpressionStatement = base.ParenthesizedExpression =
-  function (node, st, c) { return c(node.expression, st, "Expression"); }
-base.IfStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Statement")
-  if (node.alternate) c(node.alternate, st, "Statement")
-}
-base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }
-base.BreakStatement = base.ContinueStatement = ignore
-base.WithStatement = function (node, st, c) {
-  c(node.object, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.SwitchStatement = function (node, st, c) {
-  c(node.discriminant, st, "Expression")
-  for (var i = 0; i < node.cases.length; ++i) {
-    var cs = node.cases[i]
-    if (cs.test) c(cs.test, st, "Expression")
-    for (var j = 0; j < cs.consequent.length; ++j)
-      c(cs.consequent[j], st, "Statement")
-  }
-}
-base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
-  if (node.argument) c(node.argument, st, "Expression")
-}
-base.ThrowStatement = base.SpreadElement =
-  function (node, st, c) { return c(node.argument, st, "Expression"); }
-base.TryStatement = function (node, st, c) {
-  c(node.block, st, "Statement")
-  if (node.handler) c(node.handler, st)
-  if (node.finalizer) c(node.finalizer, st, "Statement")
-}
-base.CatchClause = function (node, st, c) {
-  c(node.param, st, "Pattern")
-  c(node.body, st, "ScopeBody")
-}
-base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForStatement = function (node, st, c) {
-  if (node.init) c(node.init, st, "ForInit")
-  if (node.test) c(node.test, st, "Expression")
-  if (node.update) c(node.update, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForInStatement = base.ForOfStatement = function (node, st, c) {
-  c(node.left, st, "ForInit")
-  c(node.right, st, "Expression")
-  c(node.body, st, "Statement")
-}
-base.ForInit = function (node, st, c) {
-  if (node.type == "VariableDeclaration") c(node, st)
-  else c(node, st, "Expression")
-}
-base.DebuggerStatement = ignore
-
-base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }
-base.VariableDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.declarations.length; ++i)
-    c(node.declarations[i], st)
-}
-base.VariableDeclarator = function (node, st, c) {
-  c(node.id, st, "Pattern")
-  if (node.init) c(node.init, st, "Expression")
-}
-
-base.Function = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  for (var i = 0; i < node.params.length; i++)
-    c(node.params[i], st, "Pattern")
-  c(node.body, st, node.expression ? "ScopeExpression" : "ScopeBody")
-}
-// FIXME drop these node types in next major version
-// (They are awkward, and in ES6 every block can be a scope.)
-base.ScopeBody = function (node, st, c) { return c(node, st, "Statement"); }
-base.ScopeExpression = function (node, st, c) { return c(node, st, "Expression"); }
-
-base.Pattern = function (node, st, c) {
-  if (node.type == "Identifier")
-    c(node, st, "VariablePattern")
-  else if (node.type == "MemberExpression")
-    c(node, st, "MemberPattern")
-  else
-    c(node, st)
-}
-base.VariablePattern = ignore
-base.MemberPattern = skipThrough
-base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }
-base.ArrayPattern =  function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Pattern")
-  }
-}
-base.ObjectPattern = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i].value, st, "Pattern")
-}
-
-base.Expression = skipThrough
-base.ThisExpression = base.Super = base.MetaProperty = ignore
-base.ArrayExpression = function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Expression")
-  }
-}
-base.ObjectExpression = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i], st)
-}
-base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration
-base.SequenceExpression = base.TemplateLiteral = function (node, st, c) {
-  for (var i = 0; i < node.expressions.length; ++i)
-    c(node.expressions[i], st, "Expression")
-}
-base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
-  c(node.argument, st, "Expression")
-}
-base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
-  c(node.left, st, "Expression")
-  c(node.right, st, "Expression")
-}
-base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
-  c(node.left, st, "Pattern")
-  c(node.right, st, "Expression")
-}
-base.ConditionalExpression = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Expression")
-  c(node.alternate, st, "Expression")
-}
-base.NewExpression = base.CallExpression = function (node, st, c) {
-  c(node.callee, st, "Expression")
-  if (node.arguments) for (var i = 0; i < node.arguments.length; ++i)
-    c(node.arguments[i], st, "Expression")
-}
-base.MemberExpression = function (node, st, c) {
-  c(node.object, st, "Expression")
-  if (node.computed) c(node.property, st, "Expression")
-}
-base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
-  if (node.declaration)
-    c(node.declaration, st, node.type == "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression")
-  if (node.source) c(node.source, st, "Expression")
-}
-base.ExportAllDeclaration = function (node, st, c) {
-  c(node.source, st, "Expression")
-}
-base.ImportDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.specifiers.length; i++)
-    c(node.specifiers[i], st)
-  c(node.source, st, "Expression")
-}
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore
-
-base.TaggedTemplateExpression = function (node, st, c) {
-  c(node.tag, st, "Expression")
-  c(node.quasi, st)
-}
-base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }
-base.Class = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  if (node.superClass) c(node.superClass, st, "Expression")
-  for (var i = 0; i < node.body.body.length; i++)
-    c(node.body.body[i], st)
-}
-base.MethodDefinition = base.Property = function (node, st, c) {
-  if (node.computed) c(node.key, st, "Expression")
-  c(node.value, st, "Expression")
-}
-
-exports.simple = simple;
-exports.ancestor = ancestor;
-exports.recursive = recursive;
-exports.findNodeAt = findNodeAt;
-exports.findNodeAround = findNodeAround;
-exports.findNodeAfter = findNodeAfter;
-exports.findNodeBefore = findNodeBefore;
-exports.make = make;
-exports.base = base;
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-})));

node_modules/acorn-dynamic-import/node_modules/acorn/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "acorn",
-  "description": "ECMAScript parser",
-  "homepage": "https://github.com/ternjs/acorn",
-  "main": "dist/acorn.js",
-  "jsnext:main": "dist/acorn.es.js",
-  "version": "4.0.13",
-  "engines": {
-    "node": ">=0.4.0"
-  },
-  "maintainers": [
-    {
-      "name": "Marijn Haverbeke",
-      "email": "marijnh@gmail.com",
-      "web": "http://marijnhaverbeke.nl"
-    },
-    {
-      "name": "Ingvar Stepanyan",
-      "email": "me@rreverser.com",
-      "web": "http://rreverser.com/"
-    }
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ternjs/acorn.git"
-  },
-  "license": "MIT",
-  "scripts": {
-    "prepublish": "npm test",
-    "test": "node test/run.js",
-    "pretest": "npm run build",
-    "build": "npm run build:main && npm run build:walk && npm run build:loose && npm run build:bin",
-    "build:main": "rollup -c rollup/config.main.js",
-    "build:walk": "rollup -c rollup/config.walk.js",
-    "build:loose": "rollup -c rollup/config.loose.js",
-    "build:bin": "rollup -c rollup/config.bin.js"
-  },
-  "bin": {
-    "acorn": "./bin/acorn"
-  },
-  "devDependencies": {
-    "rollup": "^0.34.1",
-    "rollup-plugin-buble": "^0.11.0",
-    "unicode-9.0.0": "^0.7.0"
-  }
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/bin/acorn.js

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

node_modules/acorn-dynamic-import/node_modules/acorn/src/expression.js

@@ -1,819 +0,0 @@
-// A recursive descent parser operates by defining functions for all
-// syntactic elements, and recursively calling those, each function
-// advancing the input stream and returning an AST node. Precedence
-// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
-// instead of `(!x)[1]` is handled by the fact that the parser
-// function that parses unary prefix operators is called first, and
-// in turn calls the function that parses `[]` subscripts — that
-// way, it'll receive the node for `x[1]` already parsed, and wraps
-// *that* in the unary operator node.
-//
-// Acorn uses an [operator precedence parser][opp] to handle binary
-// operator precedence, because it is much more compact than using
-// the technique outlined above, which uses different, nesting
-// functions to specify precedence, for all of the ten binary
-// precedence levels that JavaScript defines.
-//
-// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
-
-import {types as tt} from "./tokentype"
-import {Parser} from "./state"
-import {DestructuringErrors} from "./parseutil"
-
-const pp = Parser.prototype
-
-// Check if property name clashes with already added.
-// Object/class getters and setters are not allowed to clash —
-// either with each other or with an init property — and in
-// strict mode, init properties are also not allowed to be repeated.
-
-pp.checkPropClash = function(prop, propHash) {
-  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
-    return
-  let {key} = prop, name
-  switch (key.type) {
-  case "Identifier": name = key.name; break
-  case "Literal": name = String(key.value); break
-  default: return
-  }
-  let {kind} = prop
-  if (this.options.ecmaVersion >= 6) {
-    if (name === "__proto__" && kind === "init") {
-      if (propHash.proto) this.raiseRecoverable(key.start, "Redefinition of __proto__ property")
-      propHash.proto = true
-    }
-    return
-  }
-  name = "$" + name
-  let other = propHash[name]
-  if (other) {
-    let isGetSet = kind !== "init"
-    if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-      this.raiseRecoverable(key.start, "Redefinition of property")
-  } else {
-    other = propHash[name] = {
-      init: false,
-      get: false,
-      set: false
-    }
-  }
-  other[kind] = true
-}
-
-// ### Expression parsing
-
-// These nest, from the most general expression type at the top to
-// 'atomic', nondivisible expression types at the bottom. Most of
-// the functions will simply let the function(s) below them parse,
-// and, *if* the syntactic construct they handle is present, wrap
-// the AST node that the inner parser gave them in another node.
-
-// Parse a full expression. The optional arguments are used to
-// forbid the `in` operator (in for loops initalization expressions)
-// and provide reference for storing '=' operator inside shorthand
-// property assignment in contexts where both object expression
-// and object pattern might appear (so it's possible to raise
-// delayed syntax error at correct position).
-
-pp.parseExpression = function(noIn, refDestructuringErrors) {
-  let startPos = this.start, startLoc = this.startLoc
-  let expr = this.parseMaybeAssign(noIn, refDestructuringErrors)
-  if (this.type === tt.comma) {
-    let node = this.startNodeAt(startPos, startLoc)
-    node.expressions = [expr]
-    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors))
-    return this.finishNode(node, "SequenceExpression")
-  }
-  return expr
-}
-
-// Parse an assignment expression. This includes applications of
-// operators like `+=`.
-
-pp.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
-  if (this.inGenerator && this.isContextual("yield")) return this.parseYield()
-
-  let ownDestructuringErrors = false, oldParenAssign = -1
-  if (refDestructuringErrors) {
-    oldParenAssign = refDestructuringErrors.parenthesizedAssign
-    refDestructuringErrors.parenthesizedAssign = -1
-  } else {
-    refDestructuringErrors = new DestructuringErrors
-    ownDestructuringErrors = true
-  }
-
-  let startPos = this.start, startLoc = this.startLoc
-  if (this.type == tt.parenL || this.type == tt.name)
-    this.potentialArrowAt = this.start
-  let left = this.parseMaybeConditional(noIn, refDestructuringErrors)
-  if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc)
-  if (this.type.isAssign) {
-    this.checkPatternErrors(refDestructuringErrors, true)
-    if (!ownDestructuringErrors) DestructuringErrors.call(refDestructuringErrors)
-    let node = this.startNodeAt(startPos, startLoc)
-    node.operator = this.value
-    node.left = this.type === tt.eq ? this.toAssignable(left) : left
-    refDestructuringErrors.shorthandAssign = -1 // reset because shorthand default was used correctly
-    this.checkLVal(left)
-    this.next()
-    node.right = this.parseMaybeAssign(noIn)
-    return this.finishNode(node, "AssignmentExpression")
-  } else {
-    if (ownDestructuringErrors) this.checkExpressionErrors(refDestructuringErrors, true)
-  }
-  if (oldParenAssign > -1) refDestructuringErrors.parenthesizedAssign = oldParenAssign
-  return left
-}
-
-// Parse a ternary conditional (`?:`) operator.
-
-pp.parseMaybeConditional = function(noIn, refDestructuringErrors) {
-  let startPos = this.start, startLoc = this.startLoc
-  let expr = this.parseExprOps(noIn, refDestructuringErrors)
-  if (this.checkExpressionErrors(refDestructuringErrors)) return expr
-  if (this.eat(tt.question)) {
-    let node = this.startNodeAt(startPos, startLoc)
-    node.test = expr
-    node.consequent = this.parseMaybeAssign()
-    this.expect(tt.colon)
-    node.alternate = this.parseMaybeAssign(noIn)
-    return this.finishNode(node, "ConditionalExpression")
-  }
-  return expr
-}
-
-// Start the precedence parser.
-
-pp.parseExprOps = function(noIn, refDestructuringErrors) {
-  let startPos = this.start, startLoc = this.startLoc
-  let expr = this.parseMaybeUnary(refDestructuringErrors, false)
-  if (this.checkExpressionErrors(refDestructuringErrors)) return expr
-  return this.parseExprOp(expr, startPos, startLoc, -1, noIn)
-}
-
-// Parse binary operators with the operator precedence parsing
-// algorithm. `left` is the left-hand side of the operator.
-// `minPrec` provides context that allows the function to stop and
-// defer further parser to one of its callers when it encounters an
-// operator that has a lower precedence than the set it is parsing.
-
-pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
-  let prec = this.type.binop
-  if (prec != null && (!noIn || this.type !== tt._in)) {
-    if (prec > minPrec) {
-      let logical = this.type === tt.logicalOR || this.type === tt.logicalAND
-      let op = this.value
-      this.next()
-      let startPos = this.start, startLoc = this.startLoc
-      let right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn)
-      let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical)
-      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
-    }
-  }
-  return left
-}
-
-pp.buildBinary = function(startPos, startLoc, left, right, op, logical) {
-  let node = this.startNodeAt(startPos, startLoc)
-  node.left = left
-  node.operator = op
-  node.right = right
-  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
-}
-
-// Parse unary operators, both prefix and postfix.
-
-pp.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
-  let startPos = this.start, startLoc = this.startLoc, expr
-  if (this.inAsync && this.isContextual("await")) {
-    expr = this.parseAwait(refDestructuringErrors)
-    sawUnary = true
-  } else if (this.type.prefix) {
-    let node = this.startNode(), update = this.type === tt.incDec
-    node.operator = this.value
-    node.prefix = true
-    this.next()
-    node.argument = this.parseMaybeUnary(null, true)
-    this.checkExpressionErrors(refDestructuringErrors, true)
-    if (update) this.checkLVal(node.argument)
-    else if (this.strict && node.operator === "delete" &&
-             node.argument.type === "Identifier")
-      this.raiseRecoverable(node.start, "Deleting local variable in strict mode")
-    else sawUnary = true
-    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression")
-  } else {
-    expr = this.parseExprSubscripts(refDestructuringErrors)
-    if (this.checkExpressionErrors(refDestructuringErrors)) return expr
-    while (this.type.postfix && !this.canInsertSemicolon()) {
-      let node = this.startNodeAt(startPos, startLoc)
-      node.operator = this.value
-      node.prefix = false
-      node.argument = expr
-      this.checkLVal(expr)
-      this.next()
-      expr = this.finishNode(node, "UpdateExpression")
-    }
-  }
-
-  if (!sawUnary && this.eat(tt.starstar))
-    return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false)
-  else
-    return expr
-}
-
-// Parse call, dot, and `[]`-subscript expressions.
-
-pp.parseExprSubscripts = function(refDestructuringErrors) {
-  let startPos = this.start, startLoc = this.startLoc
-  let expr = this.parseExprAtom(refDestructuringErrors)
-  let skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")"
-  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr
-  let result = this.parseSubscripts(expr, startPos, startLoc)
-  if (refDestructuringErrors && result.type === "MemberExpression") {
-    if (refDestructuringErrors.parenthesizedAssign >= result.start) refDestructuringErrors.parenthesizedAssign = -1
-    if (refDestructuringErrors.parenthesizedBind >= result.start) refDestructuringErrors.parenthesizedBind = -1
-  }
-  return result
-}
-
-pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
-  let maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
-      this.lastTokEnd == base.end && !this.canInsertSemicolon()
-  for (let computed;;) {
-    if ((computed = this.eat(tt.bracketL)) || this.eat(tt.dot)) {
-      let node = this.startNodeAt(startPos, startLoc)
-      node.object = base
-      node.property = computed ? this.parseExpression() : this.parseIdent(true)
-      node.computed = !!computed
-      if (computed) this.expect(tt.bracketR)
-      base = this.finishNode(node, "MemberExpression")
-    } else if (!noCalls && this.eat(tt.parenL)) {
-      let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos
-      this.yieldPos = 0
-      this.awaitPos = 0
-      let exprList = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors)
-      if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
-        this.checkPatternErrors(refDestructuringErrors, false)
-        this.checkYieldAwaitInDefaultParams()
-        this.yieldPos = oldYieldPos
-        this.awaitPos = oldAwaitPos
-        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)
-      }
-      this.checkExpressionErrors(refDestructuringErrors, true)
-      this.yieldPos = oldYieldPos || this.yieldPos
-      this.awaitPos = oldAwaitPos || this.awaitPos
-      let node = this.startNodeAt(startPos, startLoc)
-      node.callee = base
-      node.arguments = exprList
-      base = this.finishNode(node, "CallExpression")
-    } else if (this.type === tt.backQuote) {
-      let node = this.startNodeAt(startPos, startLoc)
-      node.tag = base
-      node.quasi = this.parseTemplate()
-      base = this.finishNode(node, "TaggedTemplateExpression")
-    } else {
-      return base
-    }
-  }
-}
-
-// Parse an atomic expression — either a single token that is an
-// expression, an expression started by a keyword like `function` or
-// `new`, or an expression wrapped in punctuation like `()`, `[]`,
-// or `{}`.
-
-pp.parseExprAtom = function(refDestructuringErrors) {
-  let node, canBeArrow = this.potentialArrowAt == this.start
-  switch (this.type) {
-  case tt._super:
-    if (!this.inFunction)
-      this.raise(this.start, "'super' outside of function or class")
-
-  case tt._this:
-    let type = this.type === tt._this ? "ThisExpression" : "Super"
-    node = this.startNode()
-    this.next()
-    return this.finishNode(node, type)
-
-  case tt.name:
-    let startPos = this.start, startLoc = this.startLoc
-    let id = this.parseIdent(this.type !== tt.name)
-    if (this.options.ecmaVersion >= 8 && id.name === "async" && !this.canInsertSemicolon() && this.eat(tt._function))
-      return this.parseFunction(this.startNodeAt(startPos, startLoc), false, false, true)
-    if (canBeArrow && !this.canInsertSemicolon()) {
-      if (this.eat(tt.arrow))
-        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false)
-      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === tt.name) {
-        id = this.parseIdent()
-        if (this.canInsertSemicolon() || !this.eat(tt.arrow))
-          this.unexpected()
-        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
-      }
-    }
-    return id
-
-  case tt.regexp:
-    let value = this.value
-    node = this.parseLiteral(value.value)
-    node.regex = {pattern: value.pattern, flags: value.flags}
-    return node
-
-  case tt.num: case tt.string:
-    return this.parseLiteral(this.value)
-
-  case tt._null: case tt._true: case tt._false:
-    node = this.startNode()
-    node.value = this.type === tt._null ? null : this.type === tt._true
-    node.raw = this.type.keyword
-    this.next()
-    return this.finishNode(node, "Literal")
-
-  case tt.parenL:
-    let start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow)
-    if (refDestructuringErrors) {
-      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
-        refDestructuringErrors.parenthesizedAssign = start
-      if (refDestructuringErrors.parenthesizedBind < 0)
-        refDestructuringErrors.parenthesizedBind = start
-    }
-    return expr
-
-  case tt.bracketL:
-    node = this.startNode()
-    this.next()
-    node.elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors)
-    return this.finishNode(node, "ArrayExpression")
-
-  case tt.braceL:
-    return this.parseObj(false, refDestructuringErrors)
-
-  case tt._function:
-    node = this.startNode()
-    this.next()
-    return this.parseFunction(node, false)
-
-  case tt._class:
-    return this.parseClass(this.startNode(), false)
-
-  case tt._new:
-    return this.parseNew()
-
-  case tt.backQuote:
-    return this.parseTemplate()
-
-  default:
-    this.unexpected()
-  }
-}
-
-pp.parseLiteral = function(value) {
-  let node = this.startNode()
-  node.value = value
-  node.raw = this.input.slice(this.start, this.end)
-  this.next()
-  return this.finishNode(node, "Literal")
-}
-
-pp.parseParenExpression = function() {
-  this.expect(tt.parenL)
-  let val = this.parseExpression()
-  this.expect(tt.parenR)
-  return val
-}
-
-pp.parseParenAndDistinguishExpression = function(canBeArrow) {
-  let startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8
-  if (this.options.ecmaVersion >= 6) {
-    this.next()
-
-    let innerStartPos = this.start, innerStartLoc = this.startLoc
-    let exprList = [], first = true, lastIsComma = false
-    let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart, innerParenStart
-    this.yieldPos = 0
-    this.awaitPos = 0
-    while (this.type !== tt.parenR) {
-      first ? first = false : this.expect(tt.comma)
-      if (allowTrailingComma && this.afterTrailingComma(tt.parenR, true)) {
-        lastIsComma = true
-        break
-      } else if (this.type === tt.ellipsis) {
-        spreadStart = this.start
-        exprList.push(this.parseParenItem(this.parseRest()))
-        if (this.type === tt.comma) this.raise(this.start, "Comma is not permitted after the rest element")
-        break
-      } else {
-        if (this.type === tt.parenL && !innerParenStart) {
-          innerParenStart = this.start
-        }
-        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem))
-      }
-    }
-    let innerEndPos = this.start, innerEndLoc = this.startLoc
-    this.expect(tt.parenR)
-
-    if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
-      this.checkPatternErrors(refDestructuringErrors, false)
-      this.checkYieldAwaitInDefaultParams()
-      if (innerParenStart) this.unexpected(innerParenStart)
-      this.yieldPos = oldYieldPos
-      this.awaitPos = oldAwaitPos
-      return this.parseParenArrowList(startPos, startLoc, exprList)
-    }
-
-    if (!exprList.length || lastIsComma) this.unexpected(this.lastTokStart)
-    if (spreadStart) this.unexpected(spreadStart)
-    this.checkExpressionErrors(refDestructuringErrors, true)
-    this.yieldPos = oldYieldPos || this.yieldPos
-    this.awaitPos = oldAwaitPos || this.awaitPos
-
-    if (exprList.length > 1) {
-      val = this.startNodeAt(innerStartPos, innerStartLoc)
-      val.expressions = exprList
-      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc)
-    } else {
-      val = exprList[0]
-    }
-  } else {
-    val = this.parseParenExpression()
-  }
-
-  if (this.options.preserveParens) {
-    let par = this.startNodeAt(startPos, startLoc)
-    par.expression = val
-    return this.finishNode(par, "ParenthesizedExpression")
-  } else {
-    return val
-  }
-}
-
-pp.parseParenItem = function(item) {
-  return item
-}
-
-pp.parseParenArrowList = function(startPos, startLoc, exprList) {
-  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
-}
-
-// New's precedence is slightly tricky. It must allow its argument to
-// be a `[]` or dot subscript expression, but not a call — at least,
-// not without wrapping it in parentheses. Thus, it uses the noCalls
-// argument to parseSubscripts to prevent it from consuming the
-// argument list.
-
-const empty = []
-
-pp.parseNew = function() {
-  let node = this.startNode()
-  let meta = this.parseIdent(true)
-  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
-    node.meta = meta
-    node.property = this.parseIdent(true)
-    if (node.property.name !== "target")
-      this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target")
-    if (!this.inFunction)
-      this.raiseRecoverable(node.start, "new.target can only be used in functions")
-    return this.finishNode(node, "MetaProperty")
-  }
-  let startPos = this.start, startLoc = this.startLoc
-  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true)
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false)
-  else node.arguments = empty
-  return this.finishNode(node, "NewExpression")
-}
-
-// Parse template expression.
-
-pp.parseTemplateElement = function() {
-  let elem = this.startNode()
-  elem.value = {
-    raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, '\n'),
-    cooked: this.value
-  }
-  this.next()
-  elem.tail = this.type === tt.backQuote
-  return this.finishNode(elem, "TemplateElement")
-}
-
-pp.parseTemplate = function() {
-  let node = this.startNode()
-  this.next()
-  node.expressions = []
-  let curElt = this.parseTemplateElement()
-  node.quasis = [curElt]
-  while (!curElt.tail) {
-    this.expect(tt.dollarBraceL)
-    node.expressions.push(this.parseExpression())
-    this.expect(tt.braceR)
-    node.quasis.push(curElt = this.parseTemplateElement())
-  }
-  this.next()
-  return this.finishNode(node, "TemplateLiteral")
-}
-
-// Parse an object literal or binding pattern.
-
-pp.parseObj = function(isPattern, refDestructuringErrors) {
-  let node = this.startNode(), first = true, propHash = {}
-  node.properties = []
-  this.next()
-  while (!this.eat(tt.braceR)) {
-    if (!first) {
-      this.expect(tt.comma)
-      if (this.afterTrailingComma(tt.braceR)) break
-    } else first = false
-
-    let prop = this.startNode(), isGenerator, isAsync, startPos, startLoc
-    if (this.options.ecmaVersion >= 6) {
-      prop.method = false
-      prop.shorthand = false
-      if (isPattern || refDestructuringErrors) {
-        startPos = this.start
-        startLoc = this.startLoc
-      }
-      if (!isPattern)
-        isGenerator = this.eat(tt.star)
-    }
-    this.parsePropertyName(prop)
-    if (!isPattern && this.options.ecmaVersion >= 8 && !isGenerator && !prop.computed &&
-        prop.key.type === "Identifier" && prop.key.name === "async" && this.type !== tt.parenL &&
-        this.type !== tt.colon && !this.canInsertSemicolon()) {
-      isAsync = true
-      this.parsePropertyName(prop, refDestructuringErrors)
-    } else {
-      isAsync = false
-    }
-    this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors)
-    this.checkPropClash(prop, propHash)
-    node.properties.push(this.finishNode(prop, "Property"))
-  }
-  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
-}
-
-pp.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors) {
-  if ((isGenerator || isAsync) && this.type === tt.colon)
-    this.unexpected()
-
-  if (this.eat(tt.colon)) {
-    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors)
-    prop.kind = "init"
-  } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
-    if (isPattern) this.unexpected()
-    prop.kind = "init"
-    prop.method = true
-    prop.value = this.parseMethod(isGenerator, isAsync)
-  } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
-             (prop.key.name === "get" || prop.key.name === "set") &&
-             (this.type != tt.comma && this.type != tt.braceR)) {
-    if (isGenerator || isAsync || isPattern) this.unexpected()
-    prop.kind = prop.key.name
-    this.parsePropertyName(prop)
-    prop.value = this.parseMethod(false)
-    let paramCount = prop.kind === "get" ? 0 : 1
-    if (prop.value.params.length !== paramCount) {
-      let start = prop.value.start
-      if (prop.kind === "get")
-        this.raiseRecoverable(start, "getter should have no params")
-      else
-        this.raiseRecoverable(start, "setter should have exactly one param")
-    } else {
-      if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
-        this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params")
-    }
-  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
-    if (this.keywords.test(prop.key.name) ||
-        (this.strict ? this.reservedWordsStrict : this.reservedWords).test(prop.key.name) ||
-        (this.inGenerator && prop.key.name == "yield") ||
-        (this.inAsync && prop.key.name == "await"))
-      this.raiseRecoverable(prop.key.start, "'" + prop.key.name + "' can not be used as shorthand property")
-    prop.kind = "init"
-    if (isPattern) {
-      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)
-    } else if (this.type === tt.eq && refDestructuringErrors) {
-      if (refDestructuringErrors.shorthandAssign < 0)
-        refDestructuringErrors.shorthandAssign = this.start
-      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)
-    } else {
-      prop.value = prop.key
-    }
-    prop.shorthand = true
-  } else this.unexpected()
-}
-
-pp.parsePropertyName = function(prop) {
-  if (this.options.ecmaVersion >= 6) {
-    if (this.eat(tt.bracketL)) {
-      prop.computed = true
-      prop.key = this.parseMaybeAssign()
-      this.expect(tt.bracketR)
-      return prop.key
-    } else {
-      prop.computed = false
-    }
-  }
-  return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true)
-}
-
-// Initialize empty function node.
-
-pp.initFunction = function(node) {
-  node.id = null
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = false
-    node.expression = false
-  }
-  if (this.options.ecmaVersion >= 8)
-    node.async = false
-}
-
-// Parse object or class method.
-
-pp.parseMethod = function(isGenerator, isAsync) {
-  let node = this.startNode(), oldInGen = this.inGenerator, oldInAsync = this.inAsync,
-      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction
-
-  this.initFunction(node)
-  if (this.options.ecmaVersion >= 6)
-    node.generator = isGenerator
-  if (this.options.ecmaVersion >= 8)
-    node.async = !!isAsync
-
-  this.inGenerator = node.generator
-  this.inAsync = node.async
-  this.yieldPos = 0
-  this.awaitPos = 0
-  this.inFunction = true
-
-  this.expect(tt.parenL)
-  node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8)
-  this.checkYieldAwaitInDefaultParams()
-  this.parseFunctionBody(node, false)
-
-  this.inGenerator = oldInGen
-  this.inAsync = oldInAsync
-  this.yieldPos = oldYieldPos
-  this.awaitPos = oldAwaitPos
-  this.inFunction = oldInFunc
-  return this.finishNode(node, "FunctionExpression")
-}
-
-// Parse arrow function expression with given parameters.
-
-pp.parseArrowExpression = function(node, params, isAsync) {
-  let oldInGen = this.inGenerator, oldInAsync = this.inAsync,
-      oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction
-
-  this.initFunction(node)
-  if (this.options.ecmaVersion >= 8)
-    node.async = !!isAsync
-
-  this.inGenerator = false
-  this.inAsync = node.async
-  this.yieldPos = 0
-  this.awaitPos = 0
-  this.inFunction = true
-
-  node.params = this.toAssignableList(params, true)
-  this.parseFunctionBody(node, true)
-
-  this.inGenerator = oldInGen
-  this.inAsync = oldInAsync
-  this.yieldPos = oldYieldPos
-  this.awaitPos = oldAwaitPos
-  this.inFunction = oldInFunc
-  return this.finishNode(node, "ArrowFunctionExpression")
-}
-
-// Parse function body and check parameters.
-
-pp.parseFunctionBody = function(node, isArrowFunction) {
-  let isExpression = isArrowFunction && this.type !== tt.braceL
-  let oldStrict = this.strict, useStrict = false
-
-  if (isExpression) {
-    node.body = this.parseMaybeAssign()
-    node.expression = true
-  } else {
-    let nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params)
-    if (!oldStrict || nonSimple) {
-      useStrict = this.strictDirective(this.end)
-      // If this is a strict mode function, verify that argument names
-      // are not repeated, and it does not try to bind the words `eval`
-      // or `arguments`.
-      if (useStrict && nonSimple)
-        this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list")
-    }
-    // Start a new scope with regard to labels and the `inFunction`
-    // flag (restore them to their old value afterwards).
-    let oldLabels = this.labels
-    this.labels = []
-    if (useStrict) this.strict = true
-    node.body = this.parseBlock(true)
-    node.expression = false
-    this.labels = oldLabels
-  }
-
-  if (oldStrict || useStrict) {
-    this.strict = true
-    if (node.id)
-      this.checkLVal(node.id, true)
-    this.checkParams(node)
-    this.strict = oldStrict
-  } else if (isArrowFunction || !this.isSimpleParamList(node.params)) {
-    this.checkParams(node)
-  }
-}
-
-pp.isSimpleParamList = function(params) {
-  for (let i = 0; i < params.length; i++)
-    if (params[i].type !== "Identifier") return false
-  return true
-}
-
-// Checks function params for various disallowed patterns such as using "eval"
-// or "arguments" and duplicate parameters.
-
-pp.checkParams = function(node) {
-  let nameHash = {}
-  for (let i = 0; i < node.params.length; i++) this.checkLVal(node.params[i], true, nameHash)
-}
-
-// Parses a comma-separated list of expressions, and returns them as
-// an array. `close` is the token type that ends the list, and
-// `allowEmpty` can be turned on to allow subsequent commas with
-// nothing in between them to be parsed as `null` (which is needed
-// for array literals).
-
-pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
-  let elts = [], first = true
-  while (!this.eat(close)) {
-    if (!first) {
-      this.expect(tt.comma)
-      if (allowTrailingComma && this.afterTrailingComma(close)) break
-    } else first = false
-
-    let elt
-    if (allowEmpty && this.type === tt.comma)
-      elt = null
-    else if (this.type === tt.ellipsis) {
-      elt = this.parseSpread(refDestructuringErrors)
-      if (refDestructuringErrors && this.type === tt.comma && refDestructuringErrors.trailingComma < 0)
-        refDestructuringErrors.trailingComma = this.start
-    } else {
-      elt = this.parseMaybeAssign(false, refDestructuringErrors)
-    }
-    elts.push(elt)
-  }
-  return elts
-}
-
-// Parse the next token as an identifier. If `liberal` is true (used
-// when parsing properties), it will also convert keywords into
-// identifiers.
-
-pp.parseIdent = function(liberal) {
-  let node = this.startNode()
-  if (liberal && this.options.allowReserved == "never") liberal = false
-  if (this.type === tt.name) {
-    if (!liberal && (this.strict ? this.reservedWordsStrict : this.reservedWords).test(this.value) &&
-        (this.options.ecmaVersion >= 6 ||
-         this.input.slice(this.start, this.end).indexOf("\\") == -1))
-      this.raiseRecoverable(this.start, "The keyword '" + this.value + "' is reserved")
-    if (this.inGenerator && this.value === "yield")
-      this.raiseRecoverable(this.start, "Can not use 'yield' as identifier inside a generator")
-    if (this.inAsync && this.value === "await")
-      this.raiseRecoverable(this.start, "Can not use 'await' as identifier inside an async function")
-    node.name = this.value
-  } else if (liberal && this.type.keyword) {
-    node.name = this.type.keyword
-  } else {
-    this.unexpected()
-  }
-  this.next()
-  return this.finishNode(node, "Identifier")
-}
-
-// Parses yield expression inside generator.
-
-pp.parseYield = function() {
-  if (!this.yieldPos) this.yieldPos = this.start
-
-  let node = this.startNode()
-  this.next()
-  if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
-    node.delegate = false
-    node.argument = null
-  } else {
-    node.delegate = this.eat(tt.star)
-    node.argument = this.parseMaybeAssign()
-  }
-  return this.finishNode(node, "YieldExpression")
-}
-
-pp.parseAwait = function() {
-  if (!this.awaitPos) this.awaitPos = this.start
-
-  let node = this.startNode()
-  this.next()
-  node.argument = this.parseMaybeUnary(null, true)
-  return this.finishNode(node, "AwaitExpression")
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/index.js

@@ -1,77 +0,0 @@
-// Acorn is a tiny, fast JavaScript parser written in JavaScript.
-//
-// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
-// various contributors and released under an MIT license.
-//
-// Git repositories for Acorn are available at
-//
-//     http://marijnhaverbeke.nl/git/acorn
-//     https://github.com/ternjs/acorn.git
-//
-// Please use the [github bug tracker][ghbt] to report issues.
-//
-// [ghbt]: https://github.com/ternjs/acorn/issues
-//
-// This file defines the main parser interface. The library also comes
-// with a [error-tolerant parser][dammit] and an
-// [abstract syntax tree walker][walk], defined in other files.
-//
-// [dammit]: acorn_loose.js
-// [walk]: util/walk.js
-
-import {Parser} from "./state"
-import "./parseutil"
-import "./statement"
-import "./lval"
-import "./expression"
-import "./location"
-
-export {Parser, plugins} from "./state"
-export {defaultOptions} from "./options"
-export {Position, SourceLocation, getLineInfo} from "./locutil"
-export {Node} from "./node"
-export {TokenType, types as tokTypes, keywords as keywordTypes} from "./tokentype"
-export {TokContext, types as tokContexts} from "./tokencontext"
-export {isIdentifierChar, isIdentifierStart} from "./identifier"
-export {Token} from "./tokenize"
-export {isNewLine, lineBreak, lineBreakG} from "./whitespace"
-
-export const version = "4.0.11"
-
-// The main exported interface (under `self.acorn` when in the
-// browser) is a `parse` function that takes a code string and
-// returns an abstract syntax tree as specified by [Mozilla parser
-// API][api].
-//
-// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
-
-export function parse(input, options) {
-  return new Parser(options, input).parse()
-}
-
-// This function tries to parse a single expression at a given
-// offset in a string. Useful for parsing mixed-language formats
-// that embed JavaScript expressions.
-
-export function parseExpressionAt(input, pos, options) {
-  let p = new Parser(options, input, pos)
-  p.nextToken()
-  return p.parseExpression()
-}
-
-// Acorn is organized as a tokenizer and a recursive-descent parser.
-// The `tokenizer` export provides an interface to the tokenizer.
-
-export function tokenizer(input, options) {
-  return new Parser(options, input)
-}
-
-// This is a terrible kludge to support the existing, pre-ES6
-// interface where the loose parser module retroactively adds exports
-// to this module.
-export let parse_dammit, LooseParser, pluginsLoose
-export function addLooseExports(parse, Parser, plugins) {
-  parse_dammit = parse
-  LooseParser = Parser
-  pluginsLoose = plugins
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/location.js

@@ -1,26 +0,0 @@
-import {Parser} from "./state"
-import {Position, getLineInfo} from "./locutil"
-
-const pp = Parser.prototype
-
-// This function is used to raise exceptions on parse errors. It
-// takes an offset integer (into the current `input`) to indicate
-// the location of the error, attaches the position to the end
-// of the error message, and then raises a `SyntaxError` with that
-// message.
-
-pp.raise = function(pos, message) {
-  let loc = getLineInfo(this.input, pos)
-  message += " (" + loc.line + ":" + loc.column + ")"
-  let err = new SyntaxError(message)
-  err.pos = pos; err.loc = loc; err.raisedAt = this.pos
-  throw err
-}
-
-pp.raiseRecoverable = pp.raise
-
-pp.curPosition = function() {
-  if (this.options.locations) {
-    return new Position(this.curLine, this.pos - this.lineStart)
-  }
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/locutil.js

@@ -1,42 +0,0 @@
-import {lineBreakG} from "./whitespace"
-
-// These are used when `options.locations` is on, for the
-// `startLoc` and `endLoc` properties.
-
-export class Position {
-  constructor(line, col) {
-    this.line = line
-    this.column = col
-  }
-
-  offset(n) {
-    return new Position(this.line, this.column + n)
-  }
-}
-
-export class SourceLocation {
-  constructor(p, start, end) {
-    this.start = start
-    this.end = end
-    if (p.sourceFile !== null) this.source = p.sourceFile
-  }
-}
-
-// The `getLineInfo` function is mostly useful when the
-// `locations` option is off (for performance reasons) and you
-// want to find the line/column position for a given character
-// offset. `input` should be the code string that the offset refers
-// into.
-
-export function getLineInfo(input, offset) {
-  for (let line = 1, cur = 0;;) {
-    lineBreakG.lastIndex = cur
-    let match = lineBreakG.exec(input)
-    if (match && match.index < offset) {
-      ++line
-      cur = match.index + match[0].length
-    } else {
-      return new Position(line, offset - cur)
-    }
-  }
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/expression.js

@@ -1,562 +0,0 @@
-import {LooseParser} from "./state"
-import {isDummy} from "./parseutil"
-import {tokTypes as tt} from "../index"
-
-const lp = LooseParser.prototype
-
-lp.checkLVal = function(expr) {
-  if (!expr) return expr
-  switch (expr.type) {
-  case "Identifier":
-  case "MemberExpression":
-    return expr
-
-  case "ParenthesizedExpression":
-    expr.expression = this.checkLVal(expr.expression)
-    return expr
-
-  default:
-    return this.dummyIdent()
-  }
-}
-
-lp.parseExpression = function(noIn) {
-  let start = this.storeCurrentPos()
-  let expr = this.parseMaybeAssign(noIn)
-  if (this.tok.type === tt.comma) {
-    let node = this.startNodeAt(start)
-    node.expressions = [expr]
-    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn))
-    return this.finishNode(node, "SequenceExpression")
-  }
-  return expr
-}
-
-lp.parseParenExpression = function() {
-  this.pushCx()
-  this.expect(tt.parenL)
-  let val = this.parseExpression()
-  this.popCx()
-  this.expect(tt.parenR)
-  return val
-}
-
-lp.parseMaybeAssign = function(noIn) {
-  if (this.toks.isContextual("yield")) {
-    let node = this.startNode()
-    this.next()
-    if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) {
-      node.delegate = false
-      node.argument = null
-    } else {
-      node.delegate = this.eat(tt.star)
-      node.argument = this.parseMaybeAssign()
-    }
-    return this.finishNode(node, "YieldExpression")
-  }
-
-  let start = this.storeCurrentPos()
-  let left = this.parseMaybeConditional(noIn)
-  if (this.tok.type.isAssign) {
-    let node = this.startNodeAt(start)
-    node.operator = this.tok.value
-    node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left)
-    this.next()
-    node.right = this.parseMaybeAssign(noIn)
-    return this.finishNode(node, "AssignmentExpression")
-  }
-  return left
-}
-
-lp.parseMaybeConditional = function(noIn) {
-  let start = this.storeCurrentPos()
-  let expr = this.parseExprOps(noIn)
-  if (this.eat(tt.question)) {
-    let node = this.startNodeAt(start)
-    node.test = expr
-    node.consequent = this.parseMaybeAssign()
-    node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent()
-    return this.finishNode(node, "ConditionalExpression")
-  }
-  return expr
-}
-
-lp.parseExprOps = function(noIn) {
-  let start = this.storeCurrentPos()
-  let indent = this.curIndent, line = this.curLineStart
-  return this.parseExprOp(this.parseMaybeUnary(false), start, -1, noIn, indent, line)
-}
-
-lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
-  if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left
-  let prec = this.tok.type.binop
-  if (prec != null && (!noIn || this.tok.type !== tt._in)) {
-    if (prec > minPrec) {
-      let node = this.startNodeAt(start)
-      node.left = left
-      node.operator = this.tok.value
-      this.next()
-      if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) {
-        node.right = this.dummyIdent()
-      } else {
-        let rightStart = this.storeCurrentPos()
-        node.right = this.parseExprOp(this.parseMaybeUnary(false), rightStart, prec, noIn, indent, line)
-      }
-      this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression")
-      return this.parseExprOp(node, start, minPrec, noIn, indent, line)
-    }
-  }
-  return left
-}
-
-lp.parseMaybeUnary = function(sawUnary) {
-  let start = this.storeCurrentPos(), expr
-  if (this.options.ecmaVersion >= 8 && this.inAsync && this.toks.isContextual("await")) {
-    expr = this.parseAwait()
-    sawUnary = true
-  } else if (this.tok.type.prefix) {
-    let node = this.startNode(), update = this.tok.type === tt.incDec
-    if (!update) sawUnary = true
-    node.operator = this.tok.value
-    node.prefix = true
-    this.next()
-    node.argument = this.parseMaybeUnary(true)
-    if (update) node.argument = this.checkLVal(node.argument)
-    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression")
-  } else if (this.tok.type === tt.ellipsis) {
-    let node = this.startNode()
-    this.next()
-    node.argument = this.parseMaybeUnary(sawUnary)
-    expr = this.finishNode(node, "SpreadElement")
-  } else {
-    expr = this.parseExprSubscripts()
-    while (this.tok.type.postfix && !this.canInsertSemicolon()) {
-      let node = this.startNodeAt(start)
-      node.operator = this.tok.value
-      node.prefix = false
-      node.argument = this.checkLVal(expr)
-      this.next()
-      expr = this.finishNode(node, "UpdateExpression")
-    }
-  }
-
-  if (!sawUnary && this.eat(tt.starstar)) {
-    let node = this.startNodeAt(start)
-    node.operator = "**"
-    node.left = expr
-    node.right = this.parseMaybeUnary(false)
-    return this.finishNode(node, "BinaryExpression")
-  }
-
-  return expr
-}
-
-lp.parseExprSubscripts = function() {
-  let start = this.storeCurrentPos()
-  return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart)
-}
-
-lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
-  for (;;) {
-    if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) {
-      if (this.tok.type == tt.dot && this.curIndent == startIndent)
-        --startIndent
-      else
-        return base
-    }
-
-    let maybeAsyncArrow = base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon()
-
-    if (this.eat(tt.dot)) {
-      let node = this.startNodeAt(start)
-      node.object = base
-      if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine())
-        node.property = this.dummyIdent()
-      else
-        node.property = this.parsePropertyAccessor() || this.dummyIdent()
-      node.computed = false
-      base = this.finishNode(node, "MemberExpression")
-    } else if (this.tok.type == tt.bracketL) {
-      this.pushCx()
-      this.next()
-      let node = this.startNodeAt(start)
-      node.object = base
-      node.property = this.parseExpression()
-      node.computed = true
-      this.popCx()
-      this.expect(tt.bracketR)
-      base = this.finishNode(node, "MemberExpression")
-    } else if (!noCalls && this.tok.type == tt.parenL) {
-      let exprList = this.parseExprList(tt.parenR)
-      if (maybeAsyncArrow && this.eat(tt.arrow))
-        return this.parseArrowExpression(this.startNodeAt(start), exprList, true)
-      let node = this.startNodeAt(start)
-      node.callee = base
-      node.arguments = exprList
-      base = this.finishNode(node, "CallExpression")
-    } else if (this.tok.type == tt.backQuote) {
-      let node = this.startNodeAt(start)
-      node.tag = base
-      node.quasi = this.parseTemplate()
-      base = this.finishNode(node, "TaggedTemplateExpression")
-    } else {
-      return base
-    }
-  }
-}
-
-lp.parseExprAtom = function() {
-  let node
-  switch (this.tok.type) {
-  case tt._this:
-  case tt._super:
-    let type = this.tok.type === tt._this ? "ThisExpression" : "Super"
-    node = this.startNode()
-    this.next()
-    return this.finishNode(node, type)
-
-  case tt.name:
-    let start = this.storeCurrentPos()
-    let id = this.parseIdent()
-    let isAsync = false
-    if (id.name === "async" && !this.canInsertSemicolon()) {
-      if (this.eat(tt._function))
-        return this.parseFunction(this.startNodeAt(start), false, true)
-      if (this.tok.type === tt.name) {
-        id = this.parseIdent()
-        isAsync = true
-      }
-    }
-    return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id], isAsync) : id
-
-  case tt.regexp:
-    node = this.startNode()
-    let val = this.tok.value
-    node.regex = {pattern: val.pattern, flags: val.flags}
-    node.value = val.value
-    node.raw = this.input.slice(this.tok.start, this.tok.end)
-    this.next()
-    return this.finishNode(node, "Literal")
-
-  case tt.num: case tt.string:
-    node = this.startNode()
-    node.value = this.tok.value
-    node.raw = this.input.slice(this.tok.start, this.tok.end)
-    this.next()
-    return this.finishNode(node, "Literal")
-
-  case tt._null: case tt._true: case tt._false:
-    node = this.startNode()
-    node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true
-    node.raw = this.tok.type.keyword
-    this.next()
-    return this.finishNode(node, "Literal")
-
-  case tt.parenL:
-    let parenStart = this.storeCurrentPos()
-    this.next()
-    let inner = this.parseExpression()
-    this.expect(tt.parenR)
-    if (this.eat(tt.arrow)) {
-      // (a,)=>a // SequenceExpression makes dummy in the last hole. Drop the dummy.
-      let params = inner.expressions || [inner]
-      if (params.length && isDummy(params[params.length - 1]))
-        params.pop()
-      return this.parseArrowExpression(this.startNodeAt(parenStart), params)
-    }
-    if (this.options.preserveParens) {
-      let par = this.startNodeAt(parenStart)
-      par.expression = inner
-      inner = this.finishNode(par, "ParenthesizedExpression")
-    }
-    return inner
-
-  case tt.bracketL:
-    node = this.startNode()
-    node.elements = this.parseExprList(tt.bracketR, true)
-    return this.finishNode(node, "ArrayExpression")
-
-  case tt.braceL:
-    return this.parseObj()
-
-  case tt._class:
-    return this.parseClass(false)
-
-  case tt._function:
-    node = this.startNode()
-    this.next()
-    return this.parseFunction(node, false)
-
-  case tt._new:
-    return this.parseNew()
-
-  case tt.backQuote:
-    return this.parseTemplate()
-
-  default:
-    return this.dummyIdent()
-  }
-}
-
-lp.parseNew = function() {
-  let node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart
-  let meta = this.parseIdent(true)
-  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
-    node.meta = meta
-    node.property = this.parseIdent(true)
-    return this.finishNode(node, "MetaProperty")
-  }
-  let start = this.storeCurrentPos()
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line)
-  if (this.tok.type == tt.parenL) {
-    node.arguments = this.parseExprList(tt.parenR)
-  } else {
-    node.arguments = []
-  }
-  return this.finishNode(node, "NewExpression")
-}
-
-lp.parseTemplateElement = function() {
-  let elem = this.startNode()
-  elem.value = {
-    raw: this.input.slice(this.tok.start, this.tok.end).replace(/\r\n?/g, '\n'),
-    cooked: this.tok.value
-  }
-  this.next()
-  elem.tail = this.tok.type === tt.backQuote
-  return this.finishNode(elem, "TemplateElement")
-}
-
-lp.parseTemplate = function() {
-  let node = this.startNode()
-  this.next()
-  node.expressions = []
-  let curElt = this.parseTemplateElement()
-  node.quasis = [curElt]
-  while (!curElt.tail) {
-    this.next()
-    node.expressions.push(this.parseExpression())
-    if (this.expect(tt.braceR)) {
-      curElt = this.parseTemplateElement()
-    } else {
-      curElt = this.startNode()
-      curElt.value = {cooked: '', raw: ''}
-      curElt.tail = true
-      this.finishNode(curElt, "TemplateElement")
-    }
-    node.quasis.push(curElt)
-  }
-  this.expect(tt.backQuote)
-  return this.finishNode(node, "TemplateLiteral")
-}
-
-lp.parseObj = function() {
-  let node = this.startNode()
-  node.properties = []
-  this.pushCx()
-  let indent = this.curIndent + 1, line = this.curLineStart
-  this.eat(tt.braceL)
-  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart }
-  while (!this.closes(tt.braceR, indent, line)) {
-    let prop = this.startNode(), isGenerator, isAsync, start
-    if (this.options.ecmaVersion >= 6) {
-      start = this.storeCurrentPos()
-      prop.method = false
-      prop.shorthand = false
-      isGenerator = this.eat(tt.star)
-    }
-    this.parsePropertyName(prop)
-    if (!prop.computed &&
-        prop.key.type === "Identifier" && prop.key.name === "async" && this.tok.type !== tt.parenL &&
-        this.tok.type !== tt.colon && !this.canInsertSemicolon()) {
-      this.parsePropertyName(prop)
-      isAsync = true
-    } else {
-      isAsync = false
-    }
-    if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue }
-    if (this.eat(tt.colon)) {
-      prop.kind = "init"
-      prop.value = this.parseMaybeAssign()
-    } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) {
-      prop.kind = "init"
-      prop.method = true
-      prop.value = this.parseMethod(isGenerator, isAsync)
-    } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-               !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
-               (this.tok.type != tt.comma && this.tok.type != tt.braceR)) {
-      prop.kind = prop.key.name
-      this.parsePropertyName(prop)
-      prop.value = this.parseMethod(false)
-    } else {
-      prop.kind = "init"
-      if (this.options.ecmaVersion >= 6) {
-        if (this.eat(tt.eq)) {
-          let assign = this.startNodeAt(start)
-          assign.operator = "="
-          assign.left = prop.key
-          assign.right = this.parseMaybeAssign()
-          prop.value = this.finishNode(assign, "AssignmentExpression")
-        } else {
-          prop.value = prop.key
-        }
-      } else {
-        prop.value = this.dummyIdent()
-      }
-      prop.shorthand = true
-    }
-    node.properties.push(this.finishNode(prop, "Property"))
-    this.eat(tt.comma)
-  }
-  this.popCx()
-  if (!this.eat(tt.braceR)) {
-    // If there is no closing brace, make the node span to the start
-    // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start
-  }
-  return this.finishNode(node, "ObjectExpression")
-}
-
-lp.parsePropertyName = function(prop) {
-  if (this.options.ecmaVersion >= 6) {
-    if (this.eat(tt.bracketL)) {
-      prop.computed = true
-      prop.key = this.parseExpression()
-      this.expect(tt.bracketR)
-      return
-    } else {
-      prop.computed = false
-    }
-  }
-  let key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent()
-  prop.key = key || this.dummyIdent()
-}
-
-lp.parsePropertyAccessor = function() {
-  if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent()
-}
-
-lp.parseIdent = function() {
-  let name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword
-  if (!name) return this.dummyIdent()
-  let node = this.startNode()
-  this.next()
-  node.name = name
-  return this.finishNode(node, "Identifier")
-}
-
-lp.initFunction = function(node) {
-  node.id = null
-  node.params = []
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = false
-    node.expression = false
-  }
-  if (this.options.ecmaVersion >= 8)
-    node.async = false
-}
-
-// Convert existing expression atom to assignable pattern
-// if possible.
-
-lp.toAssignable = function(node, binding) {
-  if (!node || node.type == "Identifier" || (node.type == "MemberExpression" && !binding)) {
-    // Okay
-  } else if (node.type == "ParenthesizedExpression") {
-    node.expression = this.toAssignable(node.expression, binding)
-  } else if (this.options.ecmaVersion < 6) {
-    return this.dummyIdent()
-  } else if (node.type == "ObjectExpression") {
-    node.type = "ObjectPattern"
-    let props = node.properties
-    for (let i = 0; i < props.length; i++)
-      props[i].value = this.toAssignable(props[i].value, binding)
-  } else if (node.type == "ArrayExpression") {
-    node.type = "ArrayPattern"
-    this.toAssignableList(node.elements, binding)
-  } else if (node.type == "SpreadElement") {
-    node.type = "RestElement"
-    node.argument = this.toAssignable(node.argument, binding)
-  } else if (node.type == "AssignmentExpression") {
-    node.type = "AssignmentPattern"
-    delete node.operator
-  } else {
-    return this.dummyIdent()
-  }
-  return node
-}
-
-lp.toAssignableList = function(exprList, binding) {
-  for (let i = 0; i < exprList.length; i++)
-    exprList[i] = this.toAssignable(exprList[i], binding)
-  return exprList
-}
-
-lp.parseFunctionParams = function(params) {
-  params = this.parseExprList(tt.parenR)
-  return this.toAssignableList(params, true)
-}
-
-lp.parseMethod = function(isGenerator, isAsync) {
-  let node = this.startNode(), oldInAsync = this.inAsync
-  this.initFunction(node)
-  if (this.options.ecmaVersion >= 6)
-    node.generator = !!isGenerator
-  if (this.options.ecmaVersion >= 8)
-    node.async = !!isAsync
-  this.inAsync = node.async
-  node.params = this.parseFunctionParams()
-  node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL
-  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock()
-  this.inAsync = oldInAsync
-  return this.finishNode(node, "FunctionExpression")
-}
-
-lp.parseArrowExpression = function(node, params, isAsync) {
-  let oldInAsync = this.inAsync
-  this.initFunction(node)
-  if (this.options.ecmaVersion >= 8)
-    node.async = !!isAsync
-  this.inAsync = node.async
-  node.params = this.toAssignableList(params, true)
-  node.expression = this.tok.type !== tt.braceL
-  node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock()
-  this.inAsync = oldInAsync
-  return this.finishNode(node, "ArrowFunctionExpression")
-}
-
-lp.parseExprList = function(close, allowEmpty) {
-  this.pushCx()
-  let indent = this.curIndent, line = this.curLineStart, elts = []
-  this.next() // Opening bracket
-  while (!this.closes(close, indent + 1, line)) {
-    if (this.eat(tt.comma)) {
-      elts.push(allowEmpty ? null : this.dummyIdent())
-      continue
-    }
-    let elt = this.parseMaybeAssign()
-    if (isDummy(elt)) {
-      if (this.closes(close, indent, line)) break
-      this.next()
-    } else {
-      elts.push(elt)
-    }
-    this.eat(tt.comma)
-  }
-  this.popCx()
-  if (!this.eat(close)) {
-    // If there is no closing brace, make the node span to the start
-    // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start
-  }
-  return elts
-}
-
-lp.parseAwait = function() {
-  let node = this.startNode()
-  this.next()
-  node.argument = this.parseMaybeUnary()
-  return this.finishNode(node, "AwaitExpression")
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/index.js

@@ -1,48 +0,0 @@
-// Acorn: Loose parser
-//
-// This module provides an alternative parser (`parse_dammit`) that
-// exposes that same interface as `parse`, but will try to parse
-// anything as JavaScript, repairing syntax error the best it can.
-// There are circumstances in which it will raise an error and give
-// up, but they are very rare. The resulting AST will be a mostly
-// valid JavaScript AST (as per the [Mozilla parser API][api], except
-// that:
-//
-// - Return outside functions is allowed
-//
-// - Label consistency (no conflicts, break only to existing labels)
-//   is not enforced.
-//
-// - Bogus Identifier nodes with a name of `"✖"` are inserted whenever
-//   the parser got too confused to return anything meaningful.
-//
-// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
-//
-// The expected use for this is to *first* try `acorn.parse`, and only
-// if that fails switch to `parse_dammit`. The loose parser might
-// parse badly indented code incorrectly, so **don't** use it as
-// your default parser.
-//
-// Quite a lot of acorn.js is duplicated here. The alternative was to
-// add a *lot* of extra cruft to that file, making it less readable
-// and slower. Copying and editing the code allowed me to make
-// invasive changes and simplifications without creating a complicated
-// tangle.
-
-import {addLooseExports, defaultOptions} from "../index"
-import {LooseParser, pluginsLoose} from "./state"
-import "./tokenize"
-import "./statement"
-import "./expression"
-
-export {LooseParser, pluginsLoose} from "./state"
-
-defaultOptions.tabSize = 4
-
-export function parse_dammit(input, options) {
-  let p = new LooseParser(input, options)
-  p.next()
-  return p.parseTopLevel()
-}
-
-addLooseExports(parse_dammit, LooseParser, pluginsLoose)

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/parseutil.js

@@ -1 +0,0 @@
-export function isDummy(node) { return node.name == "✖" }

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/state.js

@@ -1,161 +0,0 @@
-import {tokenizer, SourceLocation, tokTypes as tt, Node, lineBreak, isNewLine} from "../index"
-
-// Registered plugins
-export const pluginsLoose = {}
-
-export class LooseParser {
-  constructor(input, options = {}) {
-    this.toks = tokenizer(input, options)
-    this.options = this.toks.options
-    this.input = this.toks.input
-    this.tok = this.last = {type: tt.eof, start: 0, end: 0}
-    if (this.options.locations) {
-      let here = this.toks.curPosition()
-      this.tok.loc = new SourceLocation(this.toks, here, here)
-    }
-    this.ahead = [] // Tokens ahead
-    this.context = [] // Indentation contexted
-    this.curIndent = 0
-    this.curLineStart = 0
-    this.nextLineStart = this.lineEnd(this.curLineStart) + 1
-    this.inAsync = false
-    // Load plugins
-    this.options.pluginsLoose = options.pluginsLoose || {}
-    this.loadPlugins(this.options.pluginsLoose)
-  }
-
-  startNode() {
-    return new Node(this.toks, this.tok.start, this.options.locations ? this.tok.loc.start : null)
-  }
-
-  storeCurrentPos() {
-    return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start
-  }
-
-  startNodeAt(pos) {
-    if (this.options.locations) {
-      return new Node(this.toks, pos[0], pos[1])
-    } else {
-      return new Node(this.toks, pos)
-    }
-  }
-
-  finishNode(node, type) {
-    node.type = type
-    node.end = this.last.end
-    if (this.options.locations)
-      node.loc.end = this.last.loc.end
-    if (this.options.ranges)
-      node.range[1] = this.last.end
-    return node
-  }
-
-  dummyNode(type) {
-    let dummy = this.startNode()
-    dummy.type = type
-    dummy.end = dummy.start
-    if (this.options.locations)
-      dummy.loc.end = dummy.loc.start
-    if (this.options.ranges)
-      dummy.range[1] = dummy.start
-    this.last = {type: tt.name, start: dummy.start, end: dummy.start, loc: dummy.loc}
-    return dummy
-  }
-
-  dummyIdent() {
-    let dummy = this.dummyNode("Identifier")
-    dummy.name = "✖"
-    return dummy
-  }
-
-  dummyString() {
-    let dummy = this.dummyNode("Literal")
-    dummy.value = dummy.raw = "✖"
-    return dummy
-  }
-
-  eat(type) {
-    if (this.tok.type === type) {
-      this.next()
-      return true
-    } else {
-      return false
-    }
-  }
-
-  isContextual(name) {
-    return this.tok.type === tt.name && this.tok.value === name
-  }
-
-  eatContextual(name) {
-    return this.tok.value === name && this.eat(tt.name)
-  }
-
-  canInsertSemicolon() {
-    return this.tok.type === tt.eof || this.tok.type === tt.braceR ||
-      lineBreak.test(this.input.slice(this.last.end, this.tok.start))
-  }
-
-  semicolon() {
-    return this.eat(tt.semi)
-  }
-
-  expect(type) {
-    if (this.eat(type)) return true
-    for (let i = 1; i <= 2; i++) {
-      if (this.lookAhead(i).type == type) {
-        for (let j = 0; j < i; j++) this.next()
-        return true
-      }
-    }
-  }
-
-  pushCx() {
-    this.context.push(this.curIndent)
-  }
-
-  popCx() {
-    this.curIndent = this.context.pop()
-  }
-
-  lineEnd(pos) {
-    while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) ++pos
-    return pos
-  }
-
-  indentationAfter(pos) {
-    for (let count = 0;; ++pos) {
-      let ch = this.input.charCodeAt(pos)
-      if (ch === 32) ++count
-      else if (ch === 9) count += this.options.tabSize
-      else return count
-    }
-  }
-
-  closes(closeTok, indent, line, blockHeuristic) {
-    if (this.tok.type === closeTok || this.tok.type === tt.eof) return true
-    return line != this.curLineStart && this.curIndent < indent && this.tokenStartsLine() &&
-      (!blockHeuristic || this.nextLineStart >= this.input.length ||
-       this.indentationAfter(this.nextLineStart) < indent)
-  }
-
-  tokenStartsLine() {
-    for (let p = this.tok.start - 1; p >= this.curLineStart; --p) {
-      let ch = this.input.charCodeAt(p)
-      if (ch !== 9 && ch !== 32) return false
-    }
-    return true
-  }
-
-  extend(name, f) {
-    this[name] = f(this[name])
-  }
-
-  loadPlugins(pluginConfigs) {
-    for (let name in pluginConfigs) {
-      let plugin = pluginsLoose[name]
-      if (!plugin) throw new Error("Plugin '" + name + "' not found")
-      plugin(this, pluginConfigs[name])
-    }
-  }
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/statement.js

@@ -1,450 +0,0 @@
-import {LooseParser} from "./state"
-import {isDummy} from "./parseutil"
-import {getLineInfo, tokTypes as tt} from "../index"
-
-const lp = LooseParser.prototype
-
-lp.parseTopLevel = function() {
-  let node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0)
-  node.body = []
-  while (this.tok.type !== tt.eof) node.body.push(this.parseStatement())
-  this.last = this.tok
-  if (this.options.ecmaVersion >= 6) {
-    node.sourceType = this.options.sourceType
-  }
-  return this.finishNode(node, "Program")
-}
-
-lp.parseStatement = function() {
-  let starttype = this.tok.type, node = this.startNode(), kind
-
-  if (this.toks.isLet()) {
-    starttype = tt._var
-    kind = "let"
-  }
-
-  switch (starttype) {
-  case tt._break: case tt._continue:
-    this.next()
-    let isBreak = starttype === tt._break
-    if (this.semicolon() || this.canInsertSemicolon()) {
-      node.label = null
-    } else {
-      node.label = this.tok.type === tt.name ? this.parseIdent() : null
-      this.semicolon()
-    }
-    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
-
-  case tt._debugger:
-    this.next()
-    this.semicolon()
-    return this.finishNode(node, "DebuggerStatement")
-
-  case tt._do:
-    this.next()
-    node.body = this.parseStatement()
-    node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent()
-    this.semicolon()
-    return this.finishNode(node, "DoWhileStatement")
-
-  case tt._for:
-    this.next()
-    this.pushCx()
-    this.expect(tt.parenL)
-    if (this.tok.type === tt.semi) return this.parseFor(node, null)
-    let isLet = this.toks.isLet()
-    if (isLet || this.tok.type === tt._var || this.tok.type === tt._const) {
-      let init = this.parseVar(true, isLet ? "let" : this.tok.value)
-      if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
-        return this.parseForIn(node, init)
-      }
-      return this.parseFor(node, init)
-    }
-    let init = this.parseExpression(true)
-    if (this.tok.type === tt._in || this.isContextual("of"))
-      return this.parseForIn(node, this.toAssignable(init))
-    return this.parseFor(node, init)
-
-  case tt._function:
-    this.next()
-    return this.parseFunction(node, true)
-
-  case tt._if:
-    this.next()
-    node.test = this.parseParenExpression()
-    node.consequent = this.parseStatement()
-    node.alternate = this.eat(tt._else) ? this.parseStatement() : null
-    return this.finishNode(node, "IfStatement")
-
-  case tt._return:
-    this.next()
-    if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null
-    else { node.argument = this.parseExpression(); this.semicolon() }
-    return this.finishNode(node, "ReturnStatement")
-
-  case tt._switch:
-    let blockIndent = this.curIndent, line = this.curLineStart
-    this.next()
-    node.discriminant = this.parseParenExpression()
-    node.cases = []
-    this.pushCx()
-    this.expect(tt.braceL)
-
-    let cur
-    while (!this.closes(tt.braceR, blockIndent, line, true)) {
-      if (this.tok.type === tt._case || this.tok.type === tt._default) {
-        let isCase = this.tok.type === tt._case
-        if (cur) this.finishNode(cur, "SwitchCase")
-        node.cases.push(cur = this.startNode())
-        cur.consequent = []
-        this.next()
-        if (isCase) cur.test = this.parseExpression()
-        else cur.test = null
-        this.expect(tt.colon)
-      } else {
-        if (!cur) {
-          node.cases.push(cur = this.startNode())
-          cur.consequent = []
-          cur.test = null
-        }
-        cur.consequent.push(this.parseStatement())
-      }
-    }
-    if (cur) this.finishNode(cur, "SwitchCase")
-    this.popCx()
-    this.eat(tt.braceR)
-    return this.finishNode(node, "SwitchStatement")
-
-  case tt._throw:
-    this.next()
-    node.argument = this.parseExpression()
-    this.semicolon()
-    return this.finishNode(node, "ThrowStatement")
-
-  case tt._try:
-    this.next()
-    node.block = this.parseBlock()
-    node.handler = null
-    if (this.tok.type === tt._catch) {
-      let clause = this.startNode()
-      this.next()
-      this.expect(tt.parenL)
-      clause.param = this.toAssignable(this.parseExprAtom(), true)
-      this.expect(tt.parenR)
-      clause.body = this.parseBlock()
-      node.handler = this.finishNode(clause, "CatchClause")
-    }
-    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null
-    if (!node.handler && !node.finalizer) return node.block
-    return this.finishNode(node, "TryStatement")
-
-  case tt._var:
-  case tt._const:
-    return this.parseVar(false, kind || this.tok.value)
-
-  case tt._while:
-    this.next()
-    node.test = this.parseParenExpression()
-    node.body = this.parseStatement()
-    return this.finishNode(node, "WhileStatement")
-
-  case tt._with:
-    this.next()
-    node.object = this.parseParenExpression()
-    node.body = this.parseStatement()
-    return this.finishNode(node, "WithStatement")
-
-  case tt.braceL:
-    return this.parseBlock()
-
-  case tt.semi:
-    this.next()
-    return this.finishNode(node, "EmptyStatement")
-
-  case tt._class:
-    return this.parseClass(true)
-
-  case tt._import:
-    return this.parseImport()
-
-  case tt._export:
-    return this.parseExport()
-
-  default:
-    if (this.toks.isAsyncFunction()) {
-      this.next()
-      this.next()
-      return this.parseFunction(node, true, true)
-    }
-    let expr = this.parseExpression()
-    if (isDummy(expr)) {
-      this.next()
-      if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement")
-      return this.parseStatement()
-    } else if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) {
-      node.body = this.parseStatement()
-      node.label = expr
-      return this.finishNode(node, "LabeledStatement")
-    } else {
-      node.expression = expr
-      this.semicolon()
-      return this.finishNode(node, "ExpressionStatement")
-    }
-  }
-}
-
-lp.parseBlock = function() {
-  let node = this.startNode()
-  this.pushCx()
-  this.expect(tt.braceL)
-  let blockIndent = this.curIndent, line = this.curLineStart
-  node.body = []
-  while (!this.closes(tt.braceR, blockIndent, line, true))
-    node.body.push(this.parseStatement())
-  this.popCx()
-  this.eat(tt.braceR)
-  return this.finishNode(node, "BlockStatement")
-}
-
-lp.parseFor = function(node, init) {
-  node.init = init
-  node.test = node.update = null
-  if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression()
-  if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression()
-  this.popCx()
-  this.expect(tt.parenR)
-  node.body = this.parseStatement()
-  return this.finishNode(node, "ForStatement")
-}
-
-lp.parseForIn = function(node, init) {
-  let type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement"
-  this.next()
-  node.left = init
-  node.right = this.parseExpression()
-  this.popCx()
-  this.expect(tt.parenR)
-  node.body = this.parseStatement()
-  return this.finishNode(node, type)
-}
-
-lp.parseVar = function(noIn, kind) {
-  let node = this.startNode()
-  node.kind = kind
-  this.next()
-  node.declarations = []
-  do {
-    let decl = this.startNode()
-    decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom(), true) : this.parseIdent()
-    decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"))
-  } while (this.eat(tt.comma))
-  if (!node.declarations.length) {
-    let decl = this.startNode()
-    decl.id = this.dummyIdent()
-    node.declarations.push(this.finishNode(decl, "VariableDeclarator"))
-  }
-  if (!noIn) this.semicolon()
-  return this.finishNode(node, "VariableDeclaration")
-}
-
-lp.parseClass = function(isStatement) {
-  let node = this.startNode()
-  this.next()
-  if (isStatement == null) isStatement = this.tok.type === tt.name
-  if (this.tok.type === tt.name) node.id = this.parseIdent()
-  else if (isStatement) node.id = this.dummyIdent()
-  else node.id = null
-  node.superClass = this.eat(tt._extends) ? this.parseExpression() : null
-  node.body = this.startNode()
-  node.body.body = []
-  this.pushCx()
-  let indent = this.curIndent + 1, line = this.curLineStart
-  this.eat(tt.braceL)
-  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart }
-  while (!this.closes(tt.braceR, indent, line)) {
-    if (this.semicolon()) continue
-    let method = this.startNode(), isGenerator, isAsync
-    if (this.options.ecmaVersion >= 6) {
-      method.static = false
-      isGenerator = this.eat(tt.star)
-    }
-    this.parsePropertyName(method)
-    if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue }
-    if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" &&
-        (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) {
-      method.static = true
-      isGenerator = this.eat(tt.star)
-      this.parsePropertyName(method)
-    } else {
-      method.static = false
-    }
-    if (!method.computed &&
-        method.key.type === "Identifier" && method.key.name === "async" && this.tok.type !== tt.parenL &&
-        !this.canInsertSemicolon()) {
-      this.parsePropertyName(method)
-      isAsync = true
-    } else {
-      isAsync = false
-    }
-    if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" &&
-        !method.computed && (method.key.name === "get" || method.key.name === "set") &&
-        this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) {
-      method.kind = method.key.name
-      this.parsePropertyName(method)
-      method.value = this.parseMethod(false)
-    } else {
-      if (!method.computed && !method.static && !isGenerator && !isAsync && (
-        method.key.type === "Identifier" && method.key.name === "constructor" ||
-          method.key.type === "Literal" && method.key.value === "constructor")) {
-        method.kind = "constructor"
-      } else {
-        method.kind =  "method"
-      }
-      method.value = this.parseMethod(isGenerator, isAsync)
-    }
-    node.body.body.push(this.finishNode(method, "MethodDefinition"))
-  }
-  this.popCx()
-  if (!this.eat(tt.braceR)) {
-    // If there is no closing brace, make the node span to the start
-    // of the next token (this is useful for Tern)
-    this.last.end = this.tok.start
-    if (this.options.locations) this.last.loc.end = this.tok.loc.start
-  }
-  this.semicolon()
-  this.finishNode(node.body, "ClassBody")
-  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
-}
-
-lp.parseFunction = function(node, isStatement, isAsync) {
-  let oldInAsync = this.inAsync
-  this.initFunction(node)
-  if (this.options.ecmaVersion >= 6) {
-    node.generator = this.eat(tt.star)
-  }
-  if (this.options.ecmaVersion >= 8) {
-    node.async = !!isAsync
-  }
-  if (isStatement == null) isStatement = this.tok.type === tt.name
-  if (this.tok.type === tt.name) node.id = this.parseIdent()
-  else if (isStatement) node.id = this.dummyIdent()
-  this.inAsync = node.async
-  node.params = this.parseFunctionParams()
-  node.body = this.parseBlock()
-  this.inAsync = oldInAsync
-  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
-}
-
-lp.parseExport = function() {
-  let node = this.startNode()
-  this.next()
-  if (this.eat(tt.star)) {
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : this.dummyString()
-    return this.finishNode(node, "ExportAllDeclaration")
-  }
-  if (this.eat(tt._default)) {
-    // export default (function foo() {}) // This is FunctionExpression.
-    let isAsync
-    if (this.tok.type === tt._function || (isAsync = this.toks.isAsyncFunction())) {
-      let fNode = this.startNode()
-      this.next()
-      if (isAsync) this.next()
-      node.declaration = this.parseFunction(fNode, null, isAsync)
-    } else if (this.tok.type === tt._class) {
-      node.declaration = this.parseClass(null)
-    } else {
-      node.declaration = this.parseMaybeAssign()
-      this.semicolon()
-    }
-    return this.finishNode(node, "ExportDefaultDeclaration")
-  }
-  if (this.tok.type.keyword || this.toks.isLet() || this.toks.isAsyncFunction()) {
-    node.declaration = this.parseStatement()
-    node.specifiers = []
-    node.source = null
-  } else {
-    node.declaration = null
-    node.specifiers = this.parseExportSpecifierList()
-    node.source = this.eatContextual("from") ? this.parseExprAtom() : null
-    this.semicolon()
-  }
-  return this.finishNode(node, "ExportNamedDeclaration")
-}
-
-lp.parseImport = function() {
-  let node = this.startNode()
-  this.next()
-  if (this.tok.type === tt.string) {
-    node.specifiers = []
-    node.source = this.parseExprAtom()
-    node.kind = ''
-  } else {
-    let elt
-    if (this.tok.type === tt.name && this.tok.value !== "from") {
-      elt = this.startNode()
-      elt.local = this.parseIdent()
-      this.finishNode(elt, "ImportDefaultSpecifier")
-      this.eat(tt.comma)
-    }
-    node.specifiers = this.parseImportSpecifierList()
-    node.source = this.eatContextual("from") && this.tok.type == tt.string ? this.parseExprAtom() : this.dummyString()
-    if (elt) node.specifiers.unshift(elt)
-  }
-  this.semicolon()
-  return this.finishNode(node, "ImportDeclaration")
-}
-
-lp.parseImportSpecifierList = function() {
-  let elts = []
-  if (this.tok.type === tt.star) {
-    let elt = this.startNode()
-    this.next()
-    elt.local = this.eatContextual("as") ? this.parseIdent() : this.dummyIdent()
-    elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"))
-  } else {
-    let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart
-    this.pushCx()
-    this.eat(tt.braceL)
-    if (this.curLineStart > continuedLine) continuedLine = this.curLineStart
-    while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-      let elt = this.startNode()
-      if (this.eat(tt.star)) {
-        elt.local = this.eatContextual("as") ? this.parseIdent() : this.dummyIdent()
-        this.finishNode(elt, "ImportNamespaceSpecifier")
-      } else {
-        if (this.isContextual("from")) break
-        elt.imported = this.parseIdent()
-        if (isDummy(elt.imported)) break
-        elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported
-        this.finishNode(elt, "ImportSpecifier")
-      }
-      elts.push(elt)
-      this.eat(tt.comma)
-    }
-    this.eat(tt.braceR)
-    this.popCx()
-  }
-  return elts
-}
-
-lp.parseExportSpecifierList = function() {
-  let elts = []
-  let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart
-  this.pushCx()
-  this.eat(tt.braceL)
-  if (this.curLineStart > continuedLine) continuedLine = this.curLineStart
-  while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
-    if (this.isContextual("from")) break
-    let elt = this.startNode()
-    elt.local = this.parseIdent()
-    if (isDummy(elt.local)) break
-    elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local
-    this.finishNode(elt, "ExportSpecifier")
-    elts.push(elt)
-    this.eat(tt.comma)
-  }
-  this.eat(tt.braceR)
-  this.popCx()
-  return elts
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/loose/tokenize.js

@@ -1,108 +0,0 @@
-import {tokTypes as tt, Token, isNewLine, SourceLocation, getLineInfo, lineBreakG} from "../index"
-import {LooseParser} from "./state"
-
-const lp = LooseParser.prototype
-
-function isSpace(ch) {
-  return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewLine(ch)
-}
-
-lp.next = function() {
-  this.last = this.tok
-  if (this.ahead.length)
-    this.tok = this.ahead.shift()
-  else
-    this.tok = this.readToken()
-
-  if (this.tok.start >= this.nextLineStart) {
-    while (this.tok.start >= this.nextLineStart) {
-      this.curLineStart = this.nextLineStart
-      this.nextLineStart = this.lineEnd(this.curLineStart) + 1
-    }
-    this.curIndent = this.indentationAfter(this.curLineStart)
-  }
-}
-
-lp.readToken = function() {
-  for (;;) {
-    try {
-      this.toks.next()
-      if (this.toks.type === tt.dot &&
-          this.input.substr(this.toks.end, 1) === "." &&
-          this.options.ecmaVersion >= 6) {
-        this.toks.end++
-        this.toks.type = tt.ellipsis
-      }
-      return new Token(this.toks)
-    } catch(e) {
-      if (!(e instanceof SyntaxError)) throw e
-
-      // Try to skip some text, based on the error message, and then continue
-      let msg = e.message, pos = e.raisedAt, replace = true
-      if (/unterminated/i.test(msg)) {
-        pos = this.lineEnd(e.pos + 1)
-        if (/string/.test(msg)) {
-          replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)}
-        } else if (/regular expr/i.test(msg)) {
-          let re = this.input.slice(e.pos, pos)
-          try { re = new RegExp(re) } catch(e) {}
-          replace = {start: e.pos, end: pos, type: tt.regexp, value: re}
-        } else if (/template/.test(msg)) {
-          replace = {start: e.pos, end: pos,
-                     type: tt.template,
-                     value: this.input.slice(e.pos, pos)}
-        } else {
-          replace = false
-        }
-      } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number|expected number in radix/i.test(msg)) {
-        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos
-      } else if (/character escape|expected hexadecimal/i.test(msg)) {
-        while (pos < this.input.length) {
-          let ch = this.input.charCodeAt(pos++)
-          if (ch === 34 || ch === 39 || isNewLine(ch)) break
-        }
-      } else if (/unexpected character/i.test(msg)) {
-        pos++
-        replace = false
-      } else if (/regular expression/i.test(msg)) {
-        replace = true
-      } else {
-        throw e
-      }
-      this.resetTo(pos)
-      if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"}
-      if (replace) {
-        if (this.options.locations)
-          replace.loc = new SourceLocation(
-            this.toks,
-            getLineInfo(this.input, replace.start),
-            getLineInfo(this.input, replace.end))
-        return replace
-      }
-    }
-  }
-}
-
-lp.resetTo = function(pos) {
-  this.toks.pos = pos
-  let ch = this.input.charAt(pos - 1)
-  this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
-    /[enwfd]/.test(ch) &&
-    /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos))
-
-  if (this.options.locations) {
-    this.toks.curLine = 1
-    this.toks.lineStart = lineBreakG.lastIndex = 0
-    let match
-    while ((match = lineBreakG.exec(this.input)) && match.index < pos) {
-      ++this.toks.curLine
-      this.toks.lineStart = match.index + match[0].length
-    }
-  }
-}
-
-lp.lookAhead = function(n) {
-  while (n > this.ahead.length)
-    this.ahead.push(this.readToken())
-  return this.ahead[n - 1]
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/lval.js

@@ -1,219 +0,0 @@
-import {types as tt} from "./tokentype"
-import {Parser} from "./state"
-import {has} from "./util"
-
-const pp = Parser.prototype
-
-// Convert existing expression atom to assignable pattern
-// if possible.
-
-pp.toAssignable = function(node, isBinding) {
-  if (this.options.ecmaVersion >= 6 && node) {
-    switch (node.type) {
-      case "Identifier":
-      if (this.inAsync && node.name === "await")
-        this.raise(node.start, "Can not use 'await' as identifier inside an async function")
-      break
-
-    case "ObjectPattern":
-    case "ArrayPattern":
-      break
-
-    case "ObjectExpression":
-      node.type = "ObjectPattern"
-      for (let i = 0; i < node.properties.length; i++) {
-        let prop = node.properties[i]
-        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter")
-        this.toAssignable(prop.value, isBinding)
-      }
-      break
-
-    case "ArrayExpression":
-      node.type = "ArrayPattern"
-      this.toAssignableList(node.elements, isBinding)
-      break
-
-    case "AssignmentExpression":
-      if (node.operator === "=") {
-        node.type = "AssignmentPattern"
-        delete node.operator
-        this.toAssignable(node.left, isBinding)
-        // falls through to AssignmentPattern
-      } else {
-        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.")
-        break
-      }
-
-    case "AssignmentPattern":
-      break
-
-    case "ParenthesizedExpression":
-      node.expression = this.toAssignable(node.expression, isBinding)
-      break
-
-    case "MemberExpression":
-      if (!isBinding) break
-
-    default:
-      this.raise(node.start, "Assigning to rvalue")
-    }
-  }
-  return node
-}
-
-// Convert list of expression atoms to binding list.
-
-pp.toAssignableList = function(exprList, isBinding) {
-  let end = exprList.length
-  if (end) {
-    let last = exprList[end - 1]
-    if (last && last.type == "RestElement") {
-      --end
-    } else if (last && last.type == "SpreadElement") {
-      last.type = "RestElement"
-      let arg = last.argument
-      this.toAssignable(arg, isBinding)
-      if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-        this.unexpected(arg.start)
-      --end
-    }
-
-    if (isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
-      this.unexpected(last.argument.start)
-  }
-  for (let i = 0; i < end; i++) {
-    let elt = exprList[i]
-    if (elt) this.toAssignable(elt, isBinding)
-  }
-  return exprList
-}
-
-// Parses spread element.
-
-pp.parseSpread = function(refDestructuringErrors) {
-  let node = this.startNode()
-  this.next()
-  node.argument = this.parseMaybeAssign(false, refDestructuringErrors)
-  return this.finishNode(node, "SpreadElement")
-}
-
-pp.parseRest = function(allowNonIdent) {
-  let node = this.startNode()
-  this.next()
-
-  // RestElement inside of a function parameter must be an identifier
-  if (allowNonIdent) node.argument = this.type === tt.name ? this.parseIdent() : this.unexpected()
-  else node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected()
-
-  return this.finishNode(node, "RestElement")
-}
-
-// Parses lvalue (assignable) atom.
-
-pp.parseBindingAtom = function() {
-  if (this.options.ecmaVersion < 6) return this.parseIdent()
-  switch (this.type) {
-  case tt.name:
-    return this.parseIdent()
-
-  case tt.bracketL:
-    let node = this.startNode()
-    this.next()
-    node.elements = this.parseBindingList(tt.bracketR, true, true)
-    return this.finishNode(node, "ArrayPattern")
-
-  case tt.braceL:
-    return this.parseObj(true)
-
-  default:
-    this.unexpected()
-  }
-}
-
-pp.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowNonIdent) {
-  let elts = [], first = true
-  while (!this.eat(close)) {
-    if (first) first = false
-    else this.expect(tt.comma)
-    if (allowEmpty && this.type === tt.comma) {
-      elts.push(null)
-    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
-      break
-    } else if (this.type === tt.ellipsis) {
-      let rest = this.parseRest(allowNonIdent)
-      this.parseBindingListItem(rest)
-      elts.push(rest)
-      if (this.type === tt.comma) this.raise(this.start, "Comma is not permitted after the rest element")
-      this.expect(close)
-      break
-    } else {
-      let elem = this.parseMaybeDefault(this.start, this.startLoc)
-      this.parseBindingListItem(elem)
-      elts.push(elem)
-    }
-  }
-  return elts
-}
-
-pp.parseBindingListItem = function(param) {
-  return param
-}
-
-// Parses assignment pattern around given atom if possible.
-
-pp.parseMaybeDefault = function(startPos, startLoc, left) {
-  left = left || this.parseBindingAtom()
-  if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left
-  let node = this.startNodeAt(startPos, startLoc)
-  node.left = left
-  node.right = this.parseMaybeAssign()
-  return this.finishNode(node, "AssignmentPattern")
-}
-
-// Verify that a node is an lval — something that can be assigned
-// to.
-
-pp.checkLVal = function(expr, isBinding, checkClashes) {
-  switch (expr.type) {
-  case "Identifier":
-    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
-      this.raiseRecoverable(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode")
-    if (checkClashes) {
-      if (has(checkClashes, expr.name))
-        this.raiseRecoverable(expr.start, "Argument name clash")
-      checkClashes[expr.name] = true
-    }
-    break
-
-  case "MemberExpression":
-    if (isBinding) this.raiseRecoverable(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression")
-    break
-
-  case "ObjectPattern":
-    for (let i = 0; i < expr.properties.length; i++)
-      this.checkLVal(expr.properties[i].value, isBinding, checkClashes)
-    break
-
-  case "ArrayPattern":
-    for (let i = 0; i < expr.elements.length; i++) {
-      let elem = expr.elements[i]
-      if (elem) this.checkLVal(elem, isBinding, checkClashes)
-    }
-    break
-
-  case "AssignmentPattern":
-    this.checkLVal(expr.left, isBinding, checkClashes)
-    break
-
-  case "RestElement":
-    this.checkLVal(expr.argument, isBinding, checkClashes)
-    break
-
-  case "ParenthesizedExpression":
-    this.checkLVal(expr.expression, isBinding, checkClashes)
-    break
-
-  default:
-    this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue")
-  }
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/node.js

@@ -1,50 +0,0 @@
-import {Parser} from "./state"
-import {SourceLocation} from "./locutil"
-
-export class Node {
-  constructor(parser, pos, loc) {
-    this.type = ""
-    this.start = pos
-    this.end = 0
-    if (parser.options.locations)
-      this.loc = new SourceLocation(parser, loc)
-    if (parser.options.directSourceFile)
-      this.sourceFile = parser.options.directSourceFile
-    if (parser.options.ranges)
-      this.range = [pos, 0]
-  }
-}
-
-// Start an AST node, attaching a start offset.
-
-const pp = Parser.prototype
-
-pp.startNode = function() {
-  return new Node(this, this.start, this.startLoc)
-}
-
-pp.startNodeAt = function(pos, loc) {
-  return new Node(this, pos, loc)
-}
-
-// Finish an AST node, adding `type` and `end` properties.
-
-function finishNodeAt(node, type, pos, loc) {
-  node.type = type
-  node.end = pos
-  if (this.options.locations)
-    node.loc.end = loc
-  if (this.options.ranges)
-    node.range[1] = pos
-  return node
-}
-
-pp.finishNode = function(node, type) {
-  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
-}
-
-// Finish node at given position
-
-pp.finishNodeAt = function(node, type, pos, loc) {
-  return finishNodeAt.call(this, node, type, pos, loc)
-}

node_modules/acorn-dynamic-import/node_modules/acorn/src/options.js

@@ -1,128 +0,0 @@
-import {has, isArray} from "./util"
-import {SourceLocation} from "./locutil"
-
-// A second optional argument can be given to further configure
-// the parser process. These options are recognized:
-
-export const defaultOptions = {
-  // `ecmaVersion` indicates the ECMAScript version to parse. Must
-  // be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support
-  // for strict mode, the set of reserved words, and support for
-  // new syntax features. The default is 7.
-  ecmaVersion: 7,
-  // `sourceType` indicates the mode the code should be parsed in.
-  // Can be either `"script"` or `"module"`. This influences global
-  // strict mode and parsing of `import` and `export` declarations.
-  sourceType: "script",
-  // `onInsertedSemicolon` can be a callback that will be called
-  // when a semicolon is automatically inserted. It will be passed
-  // th position of the comma as an offset, and if `locations` is
-  // enabled, it is given the location as a `{line, column}` object
-  // as second argument.
-  onInsertedSemicolon: null,
-  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
-  // trailing commas.
-  onTrailingComma: null,
-  // By default, reserved words are only enforced if ecmaVersion >= 5.
-  // Set `allowReserved` to a boolean value to explicitly turn this on
-  // an off. When this option has the value "never", reserved words
-  // and keywords can also not be used as property names.
-  allowReserved: null,
-  // When enabled, a return at the top level is not considered an
-  // error.
-  allowReturnOutsideFunction: false,
-  // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
-  allowImportExportEverywhere: false,
-  // When enabled, hashbang directive in the beginning of file
-  // is allowed and treated as a line comment.
-  allowHashBang: false,
-  // When `locations` is on, `loc` properties holding objects with
-  // `start` and `end` properties in `{line, column}` form (with
-  // line being 1-based and column 0-based) will be attached to the
-  // nodes.
-  locations: false,
-  // A function can be passed as `onToken` option, which will
-  // cause Acorn to call that function with object in the same
-  // format as tokens returned from `tokenizer().getToken()`. Note
-  // that you are not allowed to call the parser from the
-  // callback—that will corrupt its internal state.
-  onToken: null,
-  // A function can be passed as `onComment` option, which will
-  // cause Acorn to call that function with `(block, text, start,
-  // end)` parameters whenever a comment is skipped. `block` is a
-  // boolean indicating whether this is a block (`/* */`) comment,
-  // `text` is the content of the comment, and `start` and `end` are
-  // character offsets that denote the start and end of the comment.
-  // When the `locations` option is on, two more parameters are
-  // passed, the full `{line, column}` locations of the start and
-  // end of the comments. Note that you are not allowed to call the
-  // parser from the callback—that will corrupt its internal state.
-  onComment: null,
-  // Nodes have their start and end characters offsets recorded in
-  // `start` and `end` properties (directly on the node, rather than
-  // the `loc` object, which holds line/column data. To also add a
-  // [semi-standardized][range] `range` property holding a `[start,
-  // end]` array with the same numbers, set the `ranges` option to
-  // `true`.
-  //
-  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-  ranges: false,
-  // It is possible to parse multiple files into a single AST by
-  // passing the tree produced by parsing the first file as
-  // `program` option in subsequent parses. This will add the
-  // toplevel forms of the parsed file to the `Program` (top) node
-  // of an existing parse tree.
-  program: null,
-  // When `locations` is on, you can pass this to record the source
-  // file in every node's `loc` object.
-  sourceFile: null,
-  // This value, if given, is stored in every node, whether
-  // `locations` is on or off.
-  directSourceFile: null,
-  // When enabled, parenthesized expressions are represented by
-  // (non-standard) ParenthesizedExpression nodes
-  preserveParens: false,
-  plugins: {}
-}
-
-// Interpret and default an options object
-
-export function getOptions(opts) {
-  let options = {}
-
-  for (let opt in defaultOptions)
-    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
-
-  if (options.ecmaVersion >= 2015)
-    options.ecmaVersion -= 2009
-
-  if (options.allowReserved == null)
-    options.allowReserved = options.ecmaVersion < 5
-
-  if (isArray(options.onToken)) {
-    let tokens = options.onToken
-    options.onToken = (token) => tokens.push(token)
-  }
-  if (isArray(options.onComment))
-    options.onComment = pushComment(options, options.onComment)
-
-  return options
-}
-
-function pushComment(options, array) {
-  return function (block, text, start, end, startLoc, endLoc) {
-    let comment = {
-      type: block ? 'Block' : 'Line',
-      value: text,
-      start: start,
-      end: end
-    }
-    if (options.locations)
-      comment.loc = new SourceLocation(this, startLoc, endLoc)
-    if (options.ranges)
-      comment.range = [start, end]
-    array.push(comment)
-  }
-}
-

node_modules/acorn-dynamic-import/node_modules/acorn/src/parseutil.js

@@ -1,128 +0,0 @@
-import {types as tt} from "./tokentype"
-import {Parser} from "./state"
-import {lineBreak, skipWhiteSpace} from "./whitespace"
-
-const pp = Parser.prototype
-
-// ## Parser utilities
-
-const literal = /^(?:'((?:[^\']|\.)*)'|"((?:[^\"]|\.)*)"|;)/
-pp.strictDirective = function(start) {
-  for (;;) {
-    skipWhiteSpace.lastIndex = start
-    start += skipWhiteSpace.exec(this.input)[0].length
-    let match = literal.exec(this.input.slice(start))
-    if (!match) return false
-    if ((match[1] || match[2]) == "use strict") return true
-    start += match[0].length
-  }
-}
-
-// Predicate that tests whether the next token is of the given
-// type, and if yes, consumes it as a side effect.
-
-pp.eat = function(type) {
-  if (this.type === type) {
-    this.next()
-    return true
-  } else {
-    return false
-  }
-}
-
-// Tests whether parsed token is a contextual keyword.
-
-pp.isContextual = function(name) {
-  return this.type === tt.name && this.value === name
-}
-
-// Consumes contextual keyword if possible.
-
-pp.eatContextual = function(name) {
-  return this.value === name && this.eat(tt.name)
-}
-
-// Asserts that following token is given contextual keyword.
-
-pp.expectContextual = function(name) {
-  if (!this.eatContextual(name)) this.unexpected()
-}
-
-// Test whether a semicolon can be inserted at the current position.
-
-pp.canInsertSemicolon = function() {
-  return this.type === tt.eof ||
-    this.type === tt.braceR ||
-    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
-}
-
-pp.insertSemicolon = function() {
-  if (this.canInsertSemicolon()) {
-    if (this.options.onInsertedSemicolon)
-      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
-    return true
-  }
-}
-
-// Consume a semicolon, or, failing that, see if we are allowed to
-// pretend that there is a semicolon at this position.
-
-pp.semicolon = function() {
-  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()
-}
-
-pp.afterTrailingComma = function(tokType, notNext) {
-  if (this.type == tokType) {
-    if (this.options.onTrailingComma)
-      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)
-    if (!notNext)
-      this.next()
-    return true
-  }
-}
-
-// Expect a token of a given type. If found, consume it, otherwise,
-// raise an unexpected token error.
-
-pp.expect = function(type) {
-  this.eat(type) || this.unexpected()
-}
-
-// Raise an unexpected token error.
-
-pp.unexpected = function(pos) {
-  this.raise(pos != null ? pos : this.start, "Unexpected token")
-}
-
-export class DestructuringErrors {
-  constructor() {
-    this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = -1
-  }
-}
-
-pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
-  if (!refDestructuringErrors) return
-  if (refDestructuringErrors.trailingComma > -1)
-    this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element")
-  let parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind
-  if (parens > -1) this.raiseRecoverable(parens, "Parenthesized pattern")
-}
-
-pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
-  let pos = refDestructuringErrors ? refDestructuringErrors.shorthandAssign : -1
-  if (!andThrow) return pos >= 0
-  if (pos > -1) this.raise(pos, "Shorthand property assignments are valid only in destructuring patterns")
-}
-
-pp.checkYieldAwaitInDefaultParams = function() {
-  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
-    this.raise(this.yieldPos, "Yield expression cannot be a default value")
-  if (this.awaitPos)
-    this.raise(this.awaitPos, "Await expression cannot be a default value")
-}
-
-pp.isSimpleAssignTarget = function(expr) {
-  if (expr.type === "ParenthesizedExpression")
-    return this.isSimpleAssignTarget(expr.expression)
-  return expr.type === "Identifier" || expr.type === "MemberExpression"
-}