add file

node_modules/terser-webpack-plugin/dist/TaskRunner.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _pLimit = _interopRequireDefault(require("p-limit"));
+
+var _jestWorker = _interopRequireDefault(require("jest-worker"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _minify = _interopRequireDefault(require("./minify"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const workerPath = require.resolve('./worker');
+
+class TaskRunner {
+  constructor(options = {}) {
+    this.taskGenerator = options.taskGenerator;
+    this.files = options.files;
+    this.cache = options.cache;
+    this.availableNumberOfCores = TaskRunner.getAvailableNumberOfCores(options.parallel);
+  }
+
+  static getAvailableNumberOfCores(parallel) {
+    // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+    const cpus = _os.default.cpus() || {
+      length: 1
+    };
+    return parallel === true ? cpus.length - 1 : Math.min(Number(parallel) || 0, cpus.length - 1);
+  }
+
+  async runTask(task) {
+    if (this.worker) {
+      return this.worker.transform((0, _serializeJavascript.default)(task));
+    }
+
+    return (0, _minify.default)(task);
+  }
+
+  async run() {
+    const {
+      availableNumberOfCores,
+      cache,
+      files,
+      taskGenerator
+    } = this;
+    let concurrency = Infinity;
+
+    if (availableNumberOfCores > 0) {
+      // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory
+      const numWorkers = Math.min(files.length, availableNumberOfCores);
+      concurrency = numWorkers;
+      this.worker = new _jestWorker.default(workerPath, {
+        numWorkers
+      }); // https://github.com/facebook/jest/issues/8872#issuecomment-524822081
+
+      const workerStdout = this.worker.getStdout();
+
+      if (workerStdout) {
+        workerStdout.on('data', chunk => {
+          return process.stdout.write(chunk);
+        });
+      }
+
+      const workerStderr = this.worker.getStderr();
+
+      if (workerStderr) {
+        workerStderr.on('data', chunk => {
+          return process.stderr.write(chunk);
+        });
+      }
+    }
+
+    const limit = (0, _pLimit.default)(concurrency);
+    const scheduledTasks = [];
+
+    for (const file of files) {
+      const enqueue = async task => {
+        let taskResult;
+
+        try {
+          taskResult = await this.runTask(task);
+        } catch (error) {
+          taskResult = {
+            error
+          };
+        }
+
+        if (cache.isEnabled() && !taskResult.error) {
+          taskResult = await cache.store(task, taskResult).then(() => taskResult, () => taskResult);
+        }
+
+        task.callback(taskResult);
+        return taskResult;
+      };
+
+      scheduledTasks.push(limit(() => {
+        const task = taskGenerator(file).next().value;
+
+        if (!task) {
+          // Something went wrong, for example the `cacheKeys` option throw an error
+          return Promise.resolve();
+        }
+
+        if (cache.isEnabled()) {
+          return cache.get(task).then(taskResult => task.callback(taskResult), () => enqueue(task));
+        }
+
+        return enqueue(task);
+      }));
+    }
+
+    return Promise.all(scheduledTasks);
+  }
+
+  async exit() {
+    if (!this.worker) {
+      return Promise.resolve();
+    }
+
+    return this.worker.end();
+  }
+
+}
+
+exports.default = TaskRunner;

node_modules/terser-webpack-plugin/dist/Webpack4Cache.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _cacache = _interopRequireDefault(require("cacache"));
+
+var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Webpack4Cache {
+  constructor(compiler, compilation, options) {
+    this.options = options;
+    this.cacheDir = options.cache === true ? Webpack4Cache.getCacheDirectory() : options.cache;
+  }
+
+  static getCacheDirectory() {
+    return (0, _findCacheDir.default)({
+      name: 'terser-webpack-plugin'
+    }) || _os.default.tmpdir();
+  }
+
+  isEnabled() {
+    return !!this.cacheDir;
+  }
+
+  get(task) {
+    // eslint-disable-next-line no-param-reassign
+    task.cacheIdent = task.cacheIdent || (0, _serializeJavascript.default)(task.cacheKeys);
+    return _cacache.default.get(this.cacheDir, task.cacheIdent).then(({
+      data
+    }) => JSON.parse(data));
+  }
+
+  store(task, data) {
+    return _cacache.default.put(this.cacheDir, task.cacheIdent, JSON.stringify(data));
+  }
+
+}
+
+exports.default = Webpack4Cache;

node_modules/terser-webpack-plugin/dist/Webpack5Cache.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _getLazyHashedEtag = _interopRequireDefault(require("webpack/lib/cache/getLazyHashedEtag"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _webpack = require("webpack");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-next-line import/extensions,import/no-unresolved
+class Cache {
+  constructor(compiler, compilation, options) {
+    this.compiler = compiler;
+    this.compilation = compilation;
+    this.options = options;
+  }
+
+  isEnabled() {
+    return !!this.compilation.cache;
+  }
+
+  createCacheIdent(task) {
+    const {
+      outputOptions: {
+        hashSalt,
+        hashDigest,
+        hashDigestLength,
+        hashFunction
+      }
+    } = this.compilation;
+
+    const hash = _webpack.util.createHash(hashFunction);
+
+    if (hashSalt) {
+      hash.update(hashSalt);
+    }
+
+    hash.update((0, _serializeJavascript.default)(task.cacheKeys));
+    const digest = hash.digest(hashDigest);
+    const cacheKeys = digest.substr(0, hashDigestLength);
+    return `${this.compilation.compilerPath}/TerserWebpackPlugin/${cacheKeys}/${task.file}`;
+  }
+
+  get(task) {
+    // eslint-disable-next-line no-param-reassign
+    task.cacheIdent = task.cacheIdent || this.createCacheIdent(task); // eslint-disable-next-line no-param-reassign
+
+    task.cacheETag = task.cacheETag || (0, _getLazyHashedEtag.default)(task.asset);
+    return new Promise((resolve, reject) => {
+      this.compilation.cache.get(task.cacheIdent, task.cacheETag, (err, result) => {
+        if (err) {
+          reject(err);
+        } else if (result) {
+          resolve(result);
+        } else {
+          reject();
+        }
+      });
+    });
+  }
+
+  store(task, data) {
+    return new Promise((resolve, reject) => {
+      this.compilation.cache.store(task.cacheIdent, task.cacheETag, data, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  }
+
+}
+
+exports.default = Cache;

node_modules/terser-webpack-plugin/dist/cjs.js

@@ -0,0 +1,5 @@
+"use strict";
+
+const plugin = require('./index');
+
+module.exports = plugin.default;

node_modules/terser-webpack-plugin/dist/index.js

@@ -0,0 +1,455 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _sourceMap = require("source-map");
+
+var _webpackSources = require("webpack-sources");
+
+var _RequestShortener = _interopRequireDefault(require("webpack/lib/RequestShortener"));
+
+var _webpack = require("webpack");
+
+var _schemaUtils = _interopRequireDefault(require("schema-utils"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _package = _interopRequireDefault(require("terser/package.json"));
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+var _TaskRunner = _interopRequireDefault(require("./TaskRunner"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const warningRegex = /\[.+:([0-9]+),([0-9]+)\]/;
+
+class TerserPlugin {
+  constructor(options = {}) {
+    (0, _schemaUtils.default)(_options.default, options, {
+      name: 'Terser Plugin',
+      baseDataPath: 'options'
+    });
+    const {
+      minify,
+      terserOptions = {},
+      test = /\.m?js(\?.*)?$/i,
+      chunkFilter = () => true,
+      warningsFilter = () => true,
+      extractComments = true,
+      sourceMap,
+      cache = true,
+      cacheKeys = defaultCacheKeys => defaultCacheKeys,
+      parallel = true,
+      include,
+      exclude
+    } = options;
+    this.options = {
+      test,
+      chunkFilter,
+      warningsFilter,
+      extractComments,
+      sourceMap,
+      cache,
+      cacheKeys,
+      parallel,
+      include,
+      exclude,
+      minify,
+      terserOptions
+    };
+  }
+
+  static isSourceMap(input) {
+    // All required options for `new SourceMapConsumer(...options)`
+    // https://github.com/mozilla/source-map#new-sourcemapconsumerrawsourcemap
+    return Boolean(input && input.version && input.sources && Array.isArray(input.sources) && typeof input.mappings === 'string');
+  }
+
+  static buildSourceMap(inputSourceMap) {
+    if (!inputSourceMap || !TerserPlugin.isSourceMap(inputSourceMap)) {
+      return null;
+    }
+
+    return new _sourceMap.SourceMapConsumer(inputSourceMap);
+  }
+
+  static buildError(error, file, sourceMap, requestShortener) {
+    // Handling error which should have line, col, filename and message
+    if (error.line) {
+      const original = sourceMap && sourceMap.originalPositionFor({
+        line: error.line,
+        column: error.col
+      });
+
+      if (original && original.source && requestShortener) {
+        return new Error(`${file} from Terser\n${error.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${error.line},${error.col}]${error.stack ? `\n${error.stack.split('\n').slice(1).join('\n')}` : ''}`);
+      }
+
+      return new Error(`${file} from Terser\n${error.message} [${file}:${error.line},${error.col}]${error.stack ? `\n${error.stack.split('\n').slice(1).join('\n')}` : ''}`);
+    }
+
+    if (error.stack) {
+      return new Error(`${file} from Terser\n${error.stack}`);
+    }
+
+    return new Error(`${file} from Terser\n${error.message}`);
+  }
+
+  static buildWarning(warning, file, sourceMap, requestShortener, warningsFilter) {
+    let warningMessage = warning;
+    let locationMessage = '';
+    let source = null;
+
+    if (sourceMap) {
+      const match = warningRegex.exec(warning);
+
+      if (match) {
+        const line = +match[1];
+        const column = +match[2];
+        const original = sourceMap.originalPositionFor({
+          line,
+          column
+        });
+
+        if (original && original.source && original.source !== file && requestShortener) {
+          ({
+            source
+          } = original);
+          warningMessage = `${warningMessage.replace(warningRegex, '')}`;
+          locationMessage = `[${requestShortener.shorten(original.source)}:${original.line},${original.column}]`;
+        }
+      }
+    } // Todo change order in next major release
+
+
+    if (warningsFilter && !warningsFilter(warning, source, file)) {
+      return null;
+    }
+
+    return `Terser Plugin: ${warningMessage}${locationMessage}`;
+  }
+
+  static removeQueryString(filename) {
+    let targetFilename = filename;
+    const queryStringIdx = targetFilename.indexOf('?');
+
+    if (queryStringIdx >= 0) {
+      targetFilename = targetFilename.substr(0, queryStringIdx);
+    }
+
+    return targetFilename;
+  }
+
+  static hasAsset(commentFilename, assets) {
+    const assetFilenames = Object.keys(assets).map(assetFilename => TerserPlugin.removeQueryString(assetFilename));
+    return assetFilenames.includes(TerserPlugin.removeQueryString(commentFilename));
+  }
+
+  static isWebpack4() {
+    return _webpack.version[0] === '4';
+  }
+
+  *taskGenerator(compiler, compilation, allExtractedComments, file) {
+    let inputSourceMap;
+    const asset = compilation.assets[file];
+
+    try {
+      let input;
+
+      if (this.options.sourceMap && asset.sourceAndMap) {
+        const {
+          source,
+          map
+        } = asset.sourceAndMap();
+        input = source;
+
+        if (TerserPlugin.isSourceMap(map)) {
+          inputSourceMap = map;
+        } else {
+          inputSourceMap = map;
+          compilation.warnings.push(new Error(`${file} contains invalid source map`));
+        }
+      } else {
+        input = asset.source();
+        inputSourceMap = null;
+      } // Handling comment extraction
+
+
+      let commentsFilename = false;
+
+      if (this.options.extractComments) {
+        commentsFilename = this.options.extractComments.filename || '[file].LICENSE.txt[query]';
+
+        if (TerserPlugin.isWebpack4()) {
+          // Todo remove this in next major release
+          if (typeof commentsFilename === 'function') {
+            commentsFilename = commentsFilename.bind(null, file);
+          }
+        }
+
+        let query = '';
+        let filename = file;
+        const querySplit = filename.indexOf('?');
+
+        if (querySplit >= 0) {
+          query = filename.substr(querySplit);
+          filename = filename.substr(0, querySplit);
+        }
+
+        const lastSlashIndex = filename.lastIndexOf('/');
+        const basename = lastSlashIndex === -1 ? filename : filename.substr(lastSlashIndex + 1);
+        const data = {
+          filename,
+          basename,
+          query
+        };
+        commentsFilename = compilation.getPath(commentsFilename, data);
+      }
+
+      if (commentsFilename && TerserPlugin.hasAsset(commentsFilename, compilation.assets)) {
+        // Todo make error and stop uglifing in next major release
+        compilation.warnings.push(new Error(`The comment file "${TerserPlugin.removeQueryString(commentsFilename)}" conflicts with an existing asset, this may lead to code corruption, please use a different name`));
+      }
+
+      const callback = taskResult => {
+        let {
+          code
+        } = taskResult;
+        const {
+          error,
+          map,
+          warnings
+        } = taskResult;
+        const {
+          extractedComments
+        } = taskResult;
+        let sourceMap = null;
+
+        if (error || warnings && warnings.length > 0) {
+          sourceMap = TerserPlugin.buildSourceMap(inputSourceMap);
+        } // Handling results
+        // Error case: add errors, and go to next file
+
+
+        if (error) {
+          compilation.errors.push(TerserPlugin.buildError(error, file, sourceMap, new _RequestShortener.default(compiler.context)));
+          return;
+        }
+
+        const hasExtractedComments = commentsFilename && extractedComments && extractedComments.length > 0;
+        const hasBannerForExtractedComments = hasExtractedComments && this.options.extractComments.banner !== false;
+        let outputSource;
+        let shebang;
+
+        if (hasExtractedComments && hasBannerForExtractedComments && code.startsWith('#!')) {
+          const firstNewlinePosition = code.indexOf('\n');
+          shebang = code.substring(0, firstNewlinePosition);
+          code = code.substring(firstNewlinePosition + 1);
+        }
+
+        if (map) {
+          outputSource = new _webpackSources.SourceMapSource(code, file, map, input, inputSourceMap, true);
+        } else {
+          outputSource = new _webpackSources.RawSource(code);
+        } // Write extracted comments to commentsFilename
+
+
+        if (hasExtractedComments) {
+          if (!allExtractedComments[commentsFilename]) {
+            // eslint-disable-next-line no-param-reassign
+            allExtractedComments[commentsFilename] = [];
+          } // eslint-disable-next-line no-param-reassign
+
+
+          allExtractedComments[commentsFilename] = allExtractedComments[commentsFilename].concat(extractedComments); // Add a banner to the original file
+
+          if (hasBannerForExtractedComments) {
+            let banner = this.options.extractComments.banner || `For license information please see ${_path.default.relative(_path.default.dirname(file), commentsFilename).replace(/\\/g, '/')}`;
+
+            if (typeof banner === 'function') {
+              banner = banner(commentsFilename);
+            }
+
+            if (banner) {
+              outputSource = new _webpackSources.ConcatSource(shebang ? `${shebang}\n` : '', `/*! ${banner} */\n`, outputSource);
+            }
+          }
+        } // Updating assets
+        // eslint-disable-next-line no-param-reassign
+
+
+        compilation.assets[file] = outputSource; // Handling warnings
+
+        if (warnings && warnings.length > 0) {
+          warnings.forEach(warning => {
+            const builtWarning = TerserPlugin.buildWarning(warning, file, sourceMap, new _RequestShortener.default(compiler.context), this.options.warningsFilter);
+
+            if (builtWarning) {
+              compilation.warnings.push(builtWarning);
+            }
+          });
+        }
+      };
+
+      const task = {
+        asset,
+        file,
+        input,
+        inputSourceMap,
+        commentsFilename,
+        extractComments: this.options.extractComments,
+        terserOptions: this.options.terserOptions,
+        minify: this.options.minify,
+        callback
+      };
+
+      if (TerserPlugin.isWebpack4()) {
+        const {
+          outputOptions: {
+            hashSalt,
+            hashDigest,
+            hashDigestLength,
+            hashFunction
+          }
+        } = compilation;
+
+        const hash = _webpack.util.createHash(hashFunction);
+
+        if (hashSalt) {
+          hash.update(hashSalt);
+        }
+
+        hash.update(input);
+        const digest = hash.digest(hashDigest);
+
+        if (this.options.cache) {
+          const defaultCacheKeys = {
+            terser: _package.default.version,
+            // eslint-disable-next-line global-require
+            'terser-webpack-plugin': require('../package.json').version,
+            'terser-webpack-plugin-options': this.options,
+            nodeVersion: process.version,
+            filename: file,
+            contentHash: digest.substr(0, hashDigestLength)
+          };
+          task.cacheKeys = this.options.cacheKeys(defaultCacheKeys, file);
+        }
+      } else {
+        task.cacheKeys = {
+          terser: _package.default.version,
+          // eslint-disable-next-line global-require
+          'terser-webpack-plugin': require('../package.json').version,
+          'terser-webpack-plugin-options': this.options
+        };
+      }
+
+      yield task;
+    } catch (error) {
+      compilation.errors.push(TerserPlugin.buildError(error, file, TerserPlugin.buildSourceMap(inputSourceMap), new _RequestShortener.default(compiler.context)));
+    }
+  }
+
+  apply(compiler) {
+    const {
+      devtool,
+      output,
+      plugins
+    } = compiler.options;
+    this.options.sourceMap = typeof this.options.sourceMap === 'undefined' ? devtool && !devtool.includes('eval') && !devtool.includes('cheap') && (devtool.includes('source-map') || // Todo remove when `webpack@5` support will be dropped
+    devtool.includes('sourcemap')) || plugins && plugins.some(plugin => plugin instanceof _webpack.SourceMapDevToolPlugin && plugin.options && plugin.options.columns) : Boolean(this.options.sourceMap);
+
+    if (typeof this.options.terserOptions.module === 'undefined' && typeof output.module !== 'undefined') {
+      this.options.terserOptions.module = output.module;
+    }
+
+    if (typeof this.options.terserOptions.ecma === 'undefined' && typeof output.ecmaVersion !== 'undefined') {
+      this.options.terserOptions.ecma = output.ecmaVersion;
+    }
+
+    const optimizeFn = async (compilation, chunks) => {
+      const matchObject = _webpack.ModuleFilenameHelpers.matchObject.bind( // eslint-disable-next-line no-undefined
+      undefined, this.options);
+
+      const files = [].concat(Array.from(compilation.additionalChunkAssets || [])).concat(Array.from(chunks).filter(chunk => this.options.chunkFilter && this.options.chunkFilter(chunk)).reduce((acc, chunk) => acc.concat(Array.from(chunk.files || [])), [])).filter(file => matchObject(file));
+
+      if (files.length === 0) {
+        return Promise.resolve();
+      }
+
+      const CacheEngine = TerserPlugin.isWebpack4() ? // eslint-disable-next-line global-require
+      require('./Webpack4Cache').default : // eslint-disable-next-line global-require
+      require('./Webpack5Cache').default;
+      const allExtractedComments = {};
+      const taskGenerator = this.taskGenerator.bind(this, compiler, compilation, allExtractedComments);
+      const taskRunner = new _TaskRunner.default({
+        taskGenerator,
+        files,
+        cache: new CacheEngine(compiler, compilation, this.options),
+        parallel: this.options.parallel
+      });
+      await taskRunner.run();
+      await taskRunner.exit();
+      Object.keys(allExtractedComments).forEach(commentsFilename => {
+        const extractedComments = new Set([...allExtractedComments[commentsFilename].sort()]); // eslint-disable-next-line no-param-reassign
+
+        compilation.assets[commentsFilename] = new _webpackSources.RawSource(`${Array.from(extractedComments).join('\n\n')}\n`);
+      });
+      return Promise.resolve();
+    };
+
+    const plugin = {
+      name: this.constructor.name
+    };
+    compiler.hooks.compilation.tap(plugin, compilation => {
+      if (this.options.sourceMap) {
+        compilation.hooks.buildModule.tap(plugin, moduleArg => {
+          // to get detailed location info about errors
+          // eslint-disable-next-line no-param-reassign
+          moduleArg.useSourceMap = true;
+        });
+      }
+
+      if (!TerserPlugin.isWebpack4()) {
+        const hooks = _webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+
+        const data = (0, _serializeJavascript.default)({
+          terser: _package.default.version,
+          terserOptions: this.options.terserOptions
+        });
+        hooks.chunkHash.tap(plugin, (chunk, hash) => {
+          hash.update('TerserPlugin');
+          hash.update(data);
+        });
+      } else {
+        // Todo remove after drop `webpack@4` compatibility
+        const {
+          mainTemplate,
+          chunkTemplate
+        } = compilation;
+        const data = (0, _serializeJavascript.default)({
+          terser: _package.default.version,
+          terserOptions: this.options.terserOptions
+        }); // Regenerate `contenthash` for minified assets
+
+        for (const template of [mainTemplate, chunkTemplate]) {
+          template.hooks.hashForChunk.tap(plugin, hash => {
+            hash.update('TerserPlugin');
+            hash.update(data);
+          });
+        }
+      }
+
+      compilation.hooks.optimizeChunkAssets.tapPromise(plugin, optimizeFn.bind(this, compilation));
+    });
+  }
+
+}
+
+var _default = TerserPlugin;
+exports.default = _default;

node_modules/terser-webpack-plugin/dist/minify.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const {
+  minify: terserMinify
+} = require('terser');
+
+const buildTerserOptions = ({
+  ecma,
+  warnings,
+  parse = {},
+  compress = {},
+  mangle,
+  module,
+  output,
+  toplevel,
+  nameCache,
+  ie8,
+
+  /* eslint-disable camelcase */
+  keep_classnames,
+  keep_fnames,
+
+  /* eslint-enable camelcase */
+  safari10
+} = {}) => ({
+  ecma,
+  warnings,
+  parse: { ...parse
+  },
+  compress: typeof compress === 'boolean' ? compress : { ...compress
+  },
+  // eslint-disable-next-line no-nested-ternary
+  mangle: mangle == null ? true : typeof mangle === 'boolean' ? mangle : { ...mangle
+  },
+  output: {
+    beautify: false,
+    ...output
+  },
+  module,
+  // Ignoring sourceMap from options
+  sourceMap: null,
+  toplevel,
+  nameCache,
+  ie8,
+  keep_classnames,
+  keep_fnames,
+  safari10
+});
+
+function isObject(value) {
+  const type = typeof value;
+  return value != null && (type === 'object' || type === 'function');
+}
+
+const buildComments = (options, terserOptions, extractedComments) => {
+  const condition = {};
+  const commentsOpts = terserOptions.output.comments;
+  const {
+    extractComments
+  } = options;
+  condition.preserve = typeof commentsOpts !== 'undefined' ? commentsOpts : false;
+
+  if (typeof extractComments === 'boolean' && extractComments) {
+    condition.extract = 'some';
+  } else if (typeof extractComments === 'string' || extractComments instanceof RegExp) {
+    condition.extract = extractComments;
+  } else if (typeof extractComments === 'function') {
+    condition.extract = extractComments;
+  } else if (isObject(extractComments)) {
+    condition.extract = typeof extractComments.condition === 'boolean' && extractComments.condition ? 'some' : typeof extractComments.condition !== 'undefined' ? extractComments.condition : 'some';
+  } else {
+    // No extract
+    // Preserve using "commentsOpts" or "some"
+    condition.preserve = typeof commentsOpts !== 'undefined' ? commentsOpts : 'some';
+    condition.extract = false;
+  } // Ensure that both conditions are functions
+
+
+  ['preserve', 'extract'].forEach(key => {
+    let regexStr;
+    let regex;
+
+    switch (typeof condition[key]) {
+      case 'boolean':
+        condition[key] = condition[key] ? () => true : () => false;
+        break;
+
+      case 'function':
+        break;
+
+      case 'string':
+        if (condition[key] === 'all') {
+          condition[key] = () => true;
+
+          break;
+        }
+
+        if (condition[key] === 'some') {
+          condition[key] = (astNode, comment) => {
+            return (comment.type === 'comment2' || comment.type === 'comment1') && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+          };
+
+          break;
+        }
+
+        regexStr = condition[key];
+
+        condition[key] = (astNode, comment) => {
+          return new RegExp(regexStr).test(comment.value);
+        };
+
+        break;
+
+      default:
+        regex = condition[key];
+
+        condition[key] = (astNode, comment) => regex.test(comment.value);
+
+    }
+  }); // Redefine the comments function to extract and preserve
+  // comments according to the two conditions
+
+  return (astNode, comment) => {
+    if (condition.extract(astNode, comment)) {
+      const commentText = comment.type === 'comment2' ? `/*${comment.value}*/` : `//${comment.value}`; // Don't include duplicate comments
+
+      if (!extractedComments.includes(commentText)) {
+        extractedComments.push(commentText);
+      }
+    }
+
+    return condition.preserve(astNode, comment);
+  };
+};
+
+const minify = options => {
+  const {
+    file,
+    input,
+    inputSourceMap,
+    minify: minifyFn
+  } = options;
+
+  if (minifyFn) {
+    return minifyFn({
+      [file]: input
+    }, inputSourceMap);
+  } // Copy terser options
+
+
+  const terserOptions = buildTerserOptions(options.terserOptions); // Let terser generate a SourceMap
+
+  if (inputSourceMap) {
+    terserOptions.sourceMap = {
+      asObject: true
+    };
+  }
+
+  const extractedComments = [];
+  terserOptions.output.comments = buildComments(options, terserOptions, extractedComments);
+  const {
+    error,
+    map,
+    code,
+    warnings
+  } = terserMinify({
+    [file]: input
+  }, terserOptions);
+  return {
+    error,
+    map,
+    code,
+    warnings,
+    extractedComments
+  };
+};
+
+module.exports = minify;

node_modules/terser-webpack-plugin/dist/options.json

@@ -0,0 +1,169 @@
+{
+  "additionalProperties": false,
+  "definitions": {
+    "file-conditions": {
+      "anyOf": [
+        {
+          "instanceof": "RegExp"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  },
+  "properties": {
+    "test": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/file-conditions"
+        },
+        {
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/file-conditions"
+              }
+            ]
+          },
+          "type": "array"
+        }
+      ]
+    },
+    "include": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/file-conditions"
+        },
+        {
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/file-conditions"
+              }
+            ]
+          },
+          "type": "array"
+        }
+      ]
+    },
+    "exclude": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/file-conditions"
+        },
+        {
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/file-conditions"
+              }
+            ]
+          },
+          "type": "array"
+        }
+      ]
+    },
+    "chunkFilter": {
+      "instanceof": "Function"
+    },
+    "cache": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "cacheKeys": {
+      "instanceof": "Function"
+    },
+    "parallel": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "sourceMap": {
+      "type": "boolean"
+    },
+    "minify": {
+      "instanceof": "Function"
+    },
+    "terserOptions": {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "extractComments": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "RegExp"
+        },
+        {
+          "instanceof": "Function"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "condition": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string"
+                },
+                {
+                  "instanceof": "RegExp"
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ]
+            },
+            "filename": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ]
+            },
+            "banner": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string"
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ]
+            }
+          },
+          "type": "object"
+        }
+      ]
+    },
+    "warningsFilter": {
+      "instanceof": "Function"
+    }
+  },
+  "type": "object"
+}

node_modules/terser-webpack-plugin/dist/worker.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const minify = require('./minify');
+
+function transform(options) {
+  // 'use strict' => this === undefined (Clean Scope)
+  // Safer for possible security issues, albeit not critical at all here
+  // eslint-disable-next-line no-new-func, no-param-reassign
+  options = new Function('exports', 'require', 'module', '__filename', '__dirname', `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
+  const result = minify(options);
+
+  if (result.error) {
+    throw result.error;
+  } else {
+    return result;
+  }
+}
+
+module.exports.transform = transform;