WIP - add extractor, generate snippet_data

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

@@ -0,0 +1,126 @@
+"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 _workerFarm = _interopRequireDefault(require("worker-farm"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _isWsl = _interopRequireDefault(require("is-wsl"));
+
+var _minify = _interopRequireDefault(require("./minify"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const worker = require.resolve('./worker');
+
+class TaskRunner {
+  constructor(options = {}) {
+    const {
+      cache,
+      parallel
+    } = options;
+    this.cacheDir = cache === true ? (0, _findCacheDir.default)({
+      name: 'terser-webpack-plugin'
+    }) || _os.default.tmpdir() : cache; // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+
+    const cpus = _os.default.cpus() || {
+      length: 1
+    }; // WSL sometimes freezes, error seems to be on the WSL side
+    // https://github.com/webpack-contrib/terser-webpack-plugin/issues/21
+
+    this.maxConcurrentWorkers = _isWsl.default ? 1 : parallel === true ? cpus.length - 1 : Math.min(Number(parallel) || 0, cpus.length - 1);
+  }
+
+  run(tasks, callback) {
+    /* istanbul ignore if */
+    if (!tasks.length) {
+      callback(null, []);
+      return;
+    }
+
+    if (this.maxConcurrentWorkers > 1) {
+      const workerOptions = process.platform === 'win32' ? {
+        maxConcurrentWorkers: this.maxConcurrentWorkers,
+        maxConcurrentCallsPerWorker: 1
+      } : {
+        maxConcurrentWorkers: this.maxConcurrentWorkers
+      };
+      this.workers = (0, _workerFarm.default)(workerOptions, worker);
+
+      this.boundWorkers = (options, cb) => {
+        try {
+          this.workers((0, _serializeJavascript.default)(options), cb);
+        } catch (error) {
+          // worker-farm can fail with ENOMEM or something else
+          cb(error);
+        }
+      };
+    } else {
+      this.boundWorkers = (options, cb) => {
+        try {
+          cb(null, (0, _minify.default)(options));
+        } catch (error) {
+          cb(error);
+        }
+      };
+    }
+
+    let toRun = tasks.length;
+    const results = [];
+
+    const step = (index, data) => {
+      toRun -= 1;
+      results[index] = data;
+
+      if (!toRun) {
+        callback(null, results);
+      }
+    };
+
+    tasks.forEach((task, index) => {
+      const enqueue = () => {
+        this.boundWorkers(task, (error, data) => {
+          const result = error ? {
+            error
+          } : data;
+
+          const done = () => step(index, result);
+
+          if (this.cacheDir && !result.error) {
+            _cacache.default.put(this.cacheDir, (0, _serializeJavascript.default)(task.cacheKeys), JSON.stringify(data)).then(done, done);
+          } else {
+            done();
+          }
+        });
+      };
+
+      if (this.cacheDir) {
+        _cacache.default.get(this.cacheDir, (0, _serializeJavascript.default)(task.cacheKeys)).then(({
+          data
+        }) => step(index, JSON.parse(data)), enqueue);
+      } else {
+        enqueue();
+      }
+    });
+  }
+
+  exit() {
+    if (this.workers) {
+      _workerFarm.default.end(this.workers);
+    }
+  }
+
+}
+
+exports.default = TaskRunner;

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,354 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _sourceMap = require("source-map");
+
+var _webpackSources = require("webpack-sources");
+
+var _RequestShortener = _interopRequireDefault(require("webpack/lib/RequestShortener"));
+
+var _ModuleFilenameHelpers = _interopRequireDefault(require("webpack/lib/ModuleFilenameHelpers"));
+
+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 }; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const warningRegex = /\[.+:([0-9]+),([0-9]+)\]/;
+
+class TerserPlugin {
+  constructor(options = {}) {
+    (0, _schemaUtils.default)(_options.default, options, 'Terser Plugin');
+    const {
+      minify,
+      terserOptions = {},
+      test = /\.m?js(\?.*)?$/i,
+      chunkFilter = () => true,
+      warningsFilter = () => true,
+      extractComments = false,
+      sourceMap = false,
+      cache = false,
+      cacheKeys = defaultCacheKeys => defaultCacheKeys,
+      parallel = false,
+      include,
+      exclude
+    } = options;
+    this.options = {
+      test,
+      chunkFilter,
+      warningsFilter,
+      extractComments,
+      sourceMap,
+      cache,
+      cacheKeys,
+      parallel,
+      include,
+      exclude,
+      minify,
+      terserOptions: _objectSpread({
+        output: {
+          comments: extractComments ? false : /^\**!|@preserve|@license|@cc_on/i
+        }
+      }, 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(err, file, sourceMap, requestShortener) {
+    // Handling error which should have line, col, filename and message
+    if (err.line) {
+      const original = sourceMap && sourceMap.originalPositionFor({
+        line: err.line,
+        column: err.col
+      });
+
+      if (original && original.source && requestShortener) {
+        return new Error(`${file} from Terser\n${err.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${err.line},${err.col}]`);
+      }
+
+      return new Error(`${file} from Terser\n${err.message} [${file}:${err.line},${err.col}]`);
+    } else if (err.stack) {
+      return new Error(`${file} from Terser\n${err.stack}`);
+    }
+
+    return new Error(`${file} from Terser\n${err.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}]`;
+        }
+      }
+    }
+
+    if (warningsFilter && !warningsFilter(warning, source)) {
+      return null;
+    }
+
+    return `Terser Plugin: ${warningMessage}${locationMessage}`;
+  }
+
+  apply(compiler) {
+    const buildModuleFn = moduleArg => {
+      // to get detailed location info about errors
+      moduleArg.useSourceMap = true;
+    };
+
+    const optimizeFn = (compilation, chunks, callback) => {
+      const taskRunner = new _TaskRunner.default({
+        cache: this.options.cache,
+        parallel: this.options.parallel
+      });
+      const processedAssets = new WeakSet();
+      const tasks = [];
+      const {
+        chunkFilter
+      } = this.options;
+      Array.from(chunks).filter(chunk => chunkFilter && chunkFilter(chunk)).reduce((acc, chunk) => acc.concat(chunk.files || []), []).concat(compilation.additionalChunkAssets || []).filter(_ModuleFilenameHelpers.default.matchObject.bind(null, this.options)).forEach(file => {
+        let inputSourceMap;
+        const asset = compilation.assets[file];
+
+        if (processedAssets.has(asset)) {
+          return;
+        }
+
+        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 commentsFile = false;
+
+          if (this.options.extractComments) {
+            commentsFile = this.options.extractComments.filename || `${file}.LICENSE`;
+
+            if (typeof commentsFile === 'function') {
+              commentsFile = commentsFile(file);
+            }
+          }
+
+          const task = {
+            file,
+            input,
+            inputSourceMap,
+            commentsFile,
+            extractComments: this.options.extractComments,
+            terserOptions: this.options.terserOptions,
+            minify: this.options.minify
+          };
+
+          if (this.options.cache) {
+            const defaultCacheKeys = {
+              terser: _package.default.version,
+              node_version: process.version,
+              // eslint-disable-next-line global-require
+              'terser-webpack-plugin': require('../package.json').version,
+              'terser-webpack-plugin-options': this.options,
+              hash: _crypto.default.createHash('md4').update(input).digest('hex')
+            };
+            task.cacheKeys = this.options.cacheKeys(defaultCacheKeys, file);
+          }
+
+          tasks.push(task);
+        } catch (error) {
+          compilation.errors.push(TerserPlugin.buildError(error, file, TerserPlugin.buildSourceMap(inputSourceMap), new _RequestShortener.default(compiler.context)));
+        }
+      });
+      taskRunner.run(tasks, (tasksError, results) => {
+        if (tasksError) {
+          compilation.errors.push(tasksError);
+          return;
+        }
+
+        results.forEach((data, index) => {
+          const {
+            file,
+            input,
+            inputSourceMap,
+            commentsFile
+          } = tasks[index];
+          const {
+            error,
+            map,
+            code,
+            warnings
+          } = data;
+          let {
+            extractedComments
+          } = data;
+          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;
+          }
+
+          let outputSource;
+
+          if (map) {
+            outputSource = new _webpackSources.SourceMapSource(code, file, JSON.parse(map), input, inputSourceMap);
+          } else {
+            outputSource = new _webpackSources.RawSource(code);
+          } // Write extracted comments to commentsFile
+
+
+          if (commentsFile && extractedComments && extractedComments.length > 0) {
+            if (commentsFile in compilation.assets) {
+              const commentsFileSource = compilation.assets[commentsFile].source();
+              extractedComments = extractedComments.filter(comment => !commentsFileSource.includes(comment));
+            }
+
+            if (extractedComments.length > 0) {
+              // Add a banner to the original file
+              if (this.options.extractComments.banner !== false) {
+                let banner = this.options.extractComments.banner || `For license information please see ${_path.default.posix.basename(commentsFile)}`;
+
+                if (typeof banner === 'function') {
+                  banner = banner(commentsFile);
+                }
+
+                if (banner) {
+                  outputSource = new _webpackSources.ConcatSource(`/*! ${banner} */\n`, outputSource);
+                }
+              }
+
+              const commentsSource = new _webpackSources.RawSource(`${extractedComments.join('\n\n')}\n`);
+
+              if (commentsFile in compilation.assets) {
+                // commentsFile already exists, append new comments...
+                if (compilation.assets[commentsFile] instanceof _webpackSources.ConcatSource) {
+                  compilation.assets[commentsFile].add('\n');
+                  compilation.assets[commentsFile].add(commentsSource);
+                } else {
+                  compilation.assets[commentsFile] = new _webpackSources.ConcatSource(compilation.assets[commentsFile], '\n', commentsSource);
+                }
+              } else {
+                compilation.assets[commentsFile] = commentsSource;
+              }
+            }
+          } // Updating assets
+
+
+          processedAssets.add(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);
+              }
+            });
+          }
+        });
+        taskRunner.exit();
+        callback();
+      });
+    };
+
+    const plugin = {
+      name: this.constructor.name
+    };
+    compiler.hooks.compilation.tap(plugin, compilation => {
+      if (this.options.sourceMap) {
+        compilation.hooks.buildModule.tap(plugin, buildModuleFn);
+      }
+
+      const {
+        mainTemplate,
+        chunkTemplate
+      } = compilation; // Regenerate `contenthash` for minified assets
+
+      for (const template of [mainTemplate, chunkTemplate]) {
+        template.hooks.hashForChunk.tap(plugin, hash => {
+          const data = (0, _serializeJavascript.default)({
+            terser: _package.default.version,
+            terserOptions: this.options.terserOptions
+          });
+          hash.update('TerserPlugin');
+          hash.update(data);
+        });
+      }
+
+      compilation.hooks.optimizeChunkAssets.tapAsync(plugin, optimizeFn.bind(this, compilation));
+    });
+  }
+
+}
+
+var _default = TerserPlugin;
+exports.default = _default;

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

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _terser = require("terser");
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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: _objectSpread({}, parse),
+  compress: typeof compress === 'boolean' ? compress : _objectSpread({}, compress),
+  // eslint-disable-next-line no-nested-ternary
+  mangle: mangle == null ? true : typeof mangle === 'boolean' ? mangle : _objectSpread({}, mangle),
+  output: _objectSpread({
+    shebang: true,
+    comments: false,
+    beautify: false,
+    semicolons: true
+  }, output),
+  module,
+  // Ignoring sourceMap from options
+  sourceMap: null,
+  toplevel,
+  nameCache,
+  ie8,
+  keep_classnames,
+  keep_fnames,
+  safari10
+});
+
+const buildComments = (options, terserOptions, extractedComments) => {
+  const condition = {};
+  const commentsOpts = terserOptions.output.comments; // Use /^\**!|@preserve|@license|@cc_on/i RegExp
+
+  if (typeof options.extractComments === 'boolean') {
+    condition.preserve = commentsOpts;
+    condition.extract = /^\**!|@preserve|@license|@cc_on/i;
+  } else if (typeof options.extractComments === 'string' || options.extractComments instanceof RegExp) {
+    // extractComments specifies the extract condition and commentsOpts specifies the preserve condition
+    condition.preserve = commentsOpts;
+    condition.extract = options.extractComments;
+  } else if (typeof options.extractComments === 'function') {
+    condition.preserve = commentsOpts;
+    condition.extract = options.extractComments;
+  } else if (Object.prototype.hasOwnProperty.call(options.extractComments, 'condition')) {
+    // Extract condition is given in extractComments.condition
+    condition.preserve = commentsOpts;
+    condition.extract = options.extractComments.condition;
+  } else {
+    // No extract condition is given. Extract comments that match commentsOpts instead of preserving them
+    condition.preserve = false;
+    condition.extract = commentsOpts;
+  } // 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' && /^\**!|@preserve|@license|@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,
+    extractComments,
+    minify: minifyFn
+  } = options;
+
+  if (minifyFn) {
+    return minifyFn({
+      [file]: input
+    }, inputSourceMap);
+  } // Copy terser options
+
+
+  const terserOptions = buildTerserOptions(options.terserOptions); // Add source map data
+
+  if (inputSourceMap) {
+    terserOptions.sourceMap = {
+      content: inputSourceMap
+    };
+  }
+
+  const extractedComments = [];
+
+  if (extractComments) {
+    terserOptions.output.comments = buildComments(options, terserOptions, extractedComments);
+  }
+
+  const {
+    error,
+    map,
+    code,
+    warnings
+  } = (0, _terser.minify)({
+    [file]: input
+  }, terserOptions);
+  return {
+    error,
+    map,
+    code,
+    warnings,
+    extractedComments
+  };
+};
+
+var _default = minify;
+exports.default = _default;

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,17 @@
+"use strict";
+
+var _minify = _interopRequireDefault(require("./minify"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = (options, callback) => {
+  try {
+    // '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);
+    callback(null, (0, _minify.default)(options));
+  } catch (errors) {
+    callback(errors);
+  }
+};