.editorconfig

@@ -9,5 +9,4 @@ insert_final_newline = true
 trim_trailing_whitespace = true
 
 [*.md]
-insert_final_newline = true
-trim_trailing_whitespace = false
+trim_trailing_whitespace = false

.eslintrc.js

@@ -1,4 +1,7 @@
 module.exports = {
   root: true,
-  extends: ['@webpack-contrib/eslint-config-webpack', 'prettier'],
+  extends: ["@webpack-contrib/eslint-config-webpack", "prettier"],
+  rules: {
+    "import/no-namespace": "off",
+  },
 };

.github/ISSUE_TEMPLATE.md

@@ -6,7 +6,7 @@
 
   You arrived at this template because you felt none of the other options
   matched the kind of issue you'd like to report. Please use this opportunity to
-  tell us about your particular type of issue so we can try to accomodate
+  tell us about your particular type of issue so we can try to accommodate
   similar issues in the future.
 
   PLEASE do note, if you're using this to report an issue already covered by the

.github/workflows/nodejs.yml

@@ -0,0 +1,95 @@
+name: terser-webpack-plugin
+
+on:
+  push:
+    branches:
+      - master
+      - next
+  pull_request:
+    branches:
+      - master
+      - next
+
+jobs:
+  lint:
+    name: Lint - ${{ matrix.os }} - Node v${{ matrix.node-version }}
+
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        node-version: [12.x]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Use latest NPM
+        run: sudo npm i -g npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Security audit
+        run: npm run security
+
+      - name: Check commit message
+        uses: wagoid/commitlint-github-action@v1
+
+  test:
+    name: Test - ${{ matrix.os }} - Node v${{ matrix.node-version }}, Webpack ${{ matrix.webpack-version }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        node-version: [10.x, 12.x, 14.x]
+        webpack-version: [latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Setup Git
+        if: matrix.os == 'windows-latest'
+        run: git config --global core.autocrlf input
+
+      - uses: actions/checkout@v2
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Use latest NPM on ubuntu/macos
+        if: matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
+        run: sudo npm i -g npm
+
+      - name: Use latest NPM on windows
+        if: matrix.os == 'windows-latest'
+        run: npm i -g npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install webpack ${{ matrix.webpack-version }}
+        run: npm i webpack@${{ matrix.webpack-version }}
+
+      - name: Run tests for webpack version ${{ matrix.webpack-version }}
+        run: npm run test:coverage -- --ci
+
+      - name: Submit coverage data to codecov
+        uses: codecov/codecov-action@v1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -8,6 +8,7 @@ npm-debug.log*
 /local
 /reports
 /node_modules
+/test/outputs
 
 .DS_Store
 Thumbs.db

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no-install commitlint --edit $1

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged

babel.config.js

@@ -7,10 +7,10 @@ module.exports = (api) => {
   return {
     presets: [
       [
-        '@babel/preset-env',
+        "@babel/preset-env",
         {
           targets: {
-            node: '6.9.0',
+            node: "10.13.0",
           },
         },
       ],

commitlint.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-  extends: ['@commitlint/config-conventional'],
+  extends: ["@commitlint/config-conventional"],
 };

jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: "node",
+};

lint-staged.config.js

@@ -1,4 +1,4 @@
 module.exports = {
-  '*.js': ['prettier --write', 'eslint --fix', 'git add'],
-  '*.{json,md,yml,css}': ['prettier --write', 'git add'],
+  "*.js": ["eslint --fix", "prettier --write"],
+  "*.{json,md,yml,css,ts}": ["prettier --write"],
 };

package.json

@@ -1,78 +1,84 @@
 {
   "name": "terser-webpack-plugin",
-  "version": "1.4.1",
+  "version": "5.1.4",
   "description": "Terser plugin for webpack",
   "license": "MIT",
   "repository": "webpack-contrib/terser-webpack-plugin",
   "author": "webpack Contrib Team",
   "homepage": "https://github.com/webpack-contrib/terser-webpack-plugin",
   "bugs": "https://github.com/webpack-contrib/terser-webpack-plugin/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
   "main": "dist/cjs.js",
   "engines": {
-    "node": ">= 6.9.0"
+    "node": ">= 10.13.0"
   },
   "scripts": {
     "start": "npm run build -- -w",
-    "prebuild": "npm run clean",
-    "build": "cross-env NODE_ENV=production babel src -d dist --ignore \"src/**/*.test.js\" --copy-files",
     "clean": "del-cli dist",
+    "prebuild": "npm run clean",
+    "_build:types": "tsc --declaration --emitDeclarationOnly --outDir types && prettier \"types/**/*.ts\" --write",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
     "commitlint": "commitlint --from=master",
-    "lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css}\" --list-different",
-    "lint:js": "eslint --cache src test",
+    "security": "npm audit --production",
+    "lint:prettier": "prettier --list-different .",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
     "lint": "npm-run-all -l -p \"lint:**\"",
-    "prepare": "npm run build",
-    "release": "standard-version",
-    "security": "npm audit",
     "test:only": "cross-env NODE_ENV=test jest",
-    "test:watch": "cross-env NODE_ENV=test jest --watch",
-    "test:coverage": "cross-env NODE_ENV=test jest --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
     "pretest": "npm run lint",
-    "test": "cross-env NODE_ENV=test npm run test:coverage",
-    "defaults": "webpack-defaults"
+    "test": "npm run test:coverage",
+    "prepare": "husky install && npm run build",
+    "release": "standard-version"
   },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "peerDependencies": {
-    "webpack": "^4.0.0"
+    "webpack": "^5.1.0"
   },
   "dependencies": {
-    "cacache": "^12.0.2",
-    "find-cache-dir": "^2.1.0",
-    "is-wsl": "^1.1.0",
-    "schema-utils": "^1.0.0",
-    "serialize-javascript": "^1.7.0",
+    "jest-worker": "^27.0.2",
+    "p-limit": "^3.1.0",
+    "schema-utils": "^3.0.0",
+    "serialize-javascript": "^6.0.0",
     "source-map": "^0.6.1",
-    "terser": "^4.1.2",
-    "webpack-sources": "^1.4.0",
-    "worker-farm": "^1.7.0"
+    "terser": "^5.7.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.5.5",
-    "@babel/core": "^7.5.5",
-    "@babel/preset-env": "^7.5.5",
-    "@commitlint/cli": "^8.1.0",
-    "@commitlint/config-conventional": "^8.1.0",
-    "@webpack-contrib/defaults": "^5.0.2",
+    "@babel/cli": "^7.14.5",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@commitlint/cli": "^12.1.4",
+    "@commitlint/config-conventional": "^12.1.4",
+    "@types/serialize-javascript": "^5.0.0",
     "@webpack-contrib/eslint-config-webpack": "^3.0.0",
-    "babel-jest": "^24.8.0",
-    "commitlint-azure-pipelines-cli": "^1.0.2",
-    "cross-env": "^5.2.0",
-    "del": "^4.1.1",
-    "del-cli": "^1.1.0",
-    "eslint": "^6.1.0",
-    "eslint-config-prettier": "^6.0.0",
-    "eslint-plugin-import": "^2.18.2",
-    "husky": "^3.0.2",
-    "jest": "^24.8.0",
-    "jest-junit": "^7.0.0",
-    "lint-staged": "^9.2.1",
-    "memory-fs": "^0.4.1",
+    "babel-jest": "^27.0.2",
+    "copy-webpack-plugin": "^9.0.0",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.29.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.22.1",
+    "file-loader": "^6.2.0",
+    "husky": "^6.0.0",
+    "jest": "^27.0.5",
+    "lint-staged": "^11.0.0",
+    "memfs": "^3.2.2",
     "npm-run-all": "^4.1.5",
-    "prettier": "^1.18.2",
-    "standard-version": "^7.0.0",
-    "uglify-js": "^3.6.0",
-    "webpack": "^4.38.0"
+    "prettier": "^2.3.1",
+    "standard-version": "^9.3.0",
+    "typescript": "^4.3.4",
+    "uglify-js": "^3.13.9",
+    "webpack": "^5.40.0",
+    "worker-loader": "^3.0.8"
   },
   "keywords": [
     "uglify",

src/cjs.js

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

src/minify.js

@@ -1,134 +1,190 @@
-/* eslint-disable
-  arrow-body-style
-*/
-import { minify as terserMinify } from '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: {
-    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 { minify: terserMinify } = require("terser");
+
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
+/** @typedef {import("./index.js").ExtractCommentsOptions} ExtractCommentsOptions */
+/** @typedef {import("./index.js").CustomMinifyFunction} CustomMinifyFunction */
+/** @typedef {import("terser").MinifyOptions} TerserMinifyOptions */
+/** @typedef {import("terser").MinifyOutput} MinifyOutput */
+/** @typedef {import("terser").FormatOptions} FormatOptions */
+/** @typedef {import("terser").MangleOptions} MangleOptions */
+/** @typedef {import("./index.js").ExtractCommentsFunction} ExtractCommentsFunction */
+/** @typedef {import("./index.js").ExtractCommentsCondition} ExtractCommentsCondition */
+
+/**
+ * @typedef {Object.<any, any>} CustomMinifyOptions
+ */
+
+/**
+ * @typedef {Object} InternalMinifyOptions
+ * @property {string} name
+ * @property {string} input
+ * @property {RawSourceMap} [inputSourceMap]
+ * @property {ExtractCommentsOptions} extractComments
+ * @property {CustomMinifyFunction} [minify]
+ * @property {TerserMinifyOptions | CustomMinifyOptions} minifyOptions
+ */
+
+/**
+ * @typedef {Array<string>} ExtractedComments
+ */
+
+/**
+ * @typedef {Promise<MinifyOutput & { extractedComments?: ExtractedComments}>} InternalMinifyResult
+ */
+
+/**
+ * @typedef {TerserMinifyOptions & { sourceMap: undefined } & ({ output: FormatOptions & { beautify: boolean } } | { format: FormatOptions & { beautify: boolean } })} NormalizedTerserMinifyOptions
+ */
+
+/**
+ * @param {TerserMinifyOptions} [terserOptions={}]
+ * @returns {NormalizedTerserMinifyOptions}
+ */
+function buildTerserOptions(terserOptions = {}) {
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  return {
+    ...terserOptions,
+    compress:
+      typeof terserOptions.compress === "boolean"
+        ? terserOptions.compress
+        : { ...terserOptions.compress },
+    // ecma: terserOptions.ecma,
+    // ie8: terserOptions.ie8,
+    // keep_classnames: terserOptions.keep_classnames,
+    // keep_fnames: terserOptions.keep_fnames,
+    mangle:
+      terserOptions.mangle == null
+        ? true
+        : typeof terserOptions.mangle === "boolean"
+        ? terserOptions.mangle
+        : { ...terserOptions.mangle },
+    // module: terserOptions.module,
+    // nameCache: { ...terserOptions.toplevel },
+    // the `output` option is deprecated
+    ...(terserOptions.format
+      ? { format: { beautify: false, ...terserOptions.format } }
+      : { output: { beautify: false, ...terserOptions.output } }),
+    parse: { ...terserOptions.parse },
+    // safari10: terserOptions.safari10,
+    // Ignoring sourceMap from options
+    // eslint-disable-next-line no-undefined
+    sourceMap: undefined,
+    // toplevel: terserOptions.toplevel
+  };
+}
+
+/**
+ * @param {any} value
+ * @returns {boolean}
+ */
+function isObject(value) {
+  const type = typeof value;
+
+  return value != null && (type === "object" || type === "function");
+}
+
+/**
+ * @param {ExtractCommentsOptions} extractComments
+ * @param {NormalizedTerserMinifyOptions} terserOptions
+ * @param {ExtractedComments} extractedComments
+ * @returns {ExtractCommentsFunction}
+ */
+function buildComments(extractComments, terserOptions, extractedComments) {
+  /** @type {{ [index: string]: ExtractCommentsCondition }} */
   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;
+  let comments;
+
+  if (terserOptions.format) {
+    ({ comments } = terserOptions.format);
+  } else if (terserOptions.output) {
+    ({ comments } = terserOptions.output);
+  }
+
+  condition.preserve = typeof comments !== "undefined" ? comments : false;
+
+  if (typeof extractComments === "boolean" && extractComments) {
+    condition.extract = "some";
   } else if (
-    Object.prototype.hasOwnProperty.call(options.extractComments, 'condition')
+    typeof extractComments === "string" ||
+    extractComments instanceof RegExp
   ) {
-    // Extract condition is given in extractComments.condition
-    condition.preserve = commentsOpts;
-    condition.extract = options.extractComments.condition;
+    condition.extract = extractComments;
+  } else if (typeof extractComments === "function") {
+    condition.extract = extractComments;
+  } else if (extractComments && isObject(extractComments)) {
+    condition.extract =
+      typeof extractComments.condition === "boolean" &&
+      extractComments.condition
+        ? "some"
+        : typeof extractComments.condition !== "undefined"
+        ? extractComments.condition
+        : "some";
   } else {
-    // No extract condition is given. Extract comments that match commentsOpts instead of preserving them
-    condition.preserve = false;
-    condition.extract = commentsOpts;
+    // No extract
+    // Preserve using "commentsOpts" or "some"
+    condition.preserve = typeof comments !== "undefined" ? comments : "some";
+    condition.extract = false;
   }
 
   // Ensure that both conditions are functions
-  ['preserve', 'extract'].forEach((key) => {
+  ["preserve", "extract"].forEach((key) => {
+    /** @type {undefined | string} */
     let regexStr;
+    /** @type {undefined | RegExp} */
     let regex;
 
     switch (typeof condition[key]) {
-      case 'boolean':
+      case "boolean":
         condition[key] = condition[key] ? () => true : () => false;
 
         break;
-      case 'function':
+      case "function":
         break;
-      case 'string':
-        if (condition[key] === 'all') {
+      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)
-            );
-          };
+        if (condition[key] === "some") {
+          condition[key] = /** @type {ExtractCommentsFunction} */ (
+            (astNode, comment) =>
+              (comment.type === "comment2" || comment.type === "comment1") &&
+              /@preserve|@lic|@cc_on|^\**!/i.test(comment.value)
+          );
 
           break;
         }
 
-        regexStr = condition[key];
+        regexStr = /** @type {string} */ (condition[key]);
 
-        condition[key] = (astNode, comment) => {
-          return new RegExp(regexStr).test(comment.value);
-        };
+        condition[key] = /** @type {ExtractCommentsFunction} */ (
+          (astNode, comment) =>
+            new RegExp(/** @type {string} */ (regexStr)).test(comment.value)
+        );
 
         break;
       default:
-        regex = condition[key];
+        regex = /** @type {RegExp} */ (condition[key]);
 
-        condition[key] = (astNode, comment) => regex.test(comment.value);
+        condition[key] = /** @type {ExtractCommentsFunction} */ (
+          (astNode, comment) =>
+            /** @type {RegExp} */ (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)) {
+    if (
+      /** @type {{ extract: ExtractCommentsFunction }} */
+      (condition).extract(astNode, comment)
+    ) {
       const commentText =
-        comment.type === 'comment2'
+        comment.type === "comment2"
           ? `/*${comment.value}*/`
           : `//${comment.value}`;
 
@@ -138,47 +194,85 @@ const buildComments = (options, terserOptions, extractedComments) => {
       }
     }
 
-    return condition.preserve(astNode, comment);
+    return /** @type {{ preserve: ExtractCommentsFunction }} */ (
+      condition
+    ).preserve(astNode, comment);
   };
-};
+}
 
-const minify = (options) => {
+/**
+ * @param {InternalMinifyOptions} options
+ * @returns {InternalMinifyResult}
+ */
+async function minify(options) {
   const {
-    file,
+    name,
     input,
     inputSourceMap,
-    extractComments,
     minify: minifyFn,
+    minifyOptions,
   } = options;
 
   if (minifyFn) {
-    return minifyFn({ [file]: input }, inputSourceMap);
+    return minifyFn({ [name]: input }, inputSourceMap, minifyOptions);
   }
 
   // Copy terser options
-  const terserOptions = buildTerserOptions(options.terserOptions);
+  const terserOptions = buildTerserOptions(minifyOptions);
 
   // Let terser generate a SourceMap
   if (inputSourceMap) {
-    terserOptions.sourceMap = true;
+    // @ts-ignore
+    terserOptions.sourceMap = { asObject: true };
   }
 
+  /** @type {ExtractedComments} */
   const extractedComments = [];
+  const { extractComments } = options;
 
-  if (extractComments) {
+  if (terserOptions.output) {
     terserOptions.output.comments = buildComments(
-      options,
+      extractComments,
+      terserOptions,
+      extractedComments
+    );
+  } else if (terserOptions.format) {
+    terserOptions.format.comments = buildComments(
+      extractComments,
       terserOptions,
       extractedComments
     );
   }
 
-  const { error, map, code, warnings } = terserMinify(
-    { [file]: input },
-    terserOptions
-  );
+  const result = await terserMinify({ [name]: input }, terserOptions);
+
+  return { ...result, extractedComments };
+}
+
+/**
+ * @param {string} options
+ * @returns {InternalMinifyResult}
+ */
+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-param-reassign
+  const evaluatedOptions =
+    /** @type {InternalMinifyOptions} */
+    (
+      // eslint-disable-next-line no-new-func
+      new Function(
+        "exports",
+        "require",
+        "module",
+        "__filename",
+        "__dirname",
+        `'use strict'\nreturn ${options}`
+      )(exports, require, module, __filename, __dirname)
+    );
 
-  return { error, map, code, warnings, extractedComments };
-};
+  return minify(evaluatedOptions);
+}
 
-export default minify;
+module.exports.minify = minify;
+module.exports.transform = transform;

src/options.json

@@ -1,112 +1,80 @@
 {
-  "additionalProperties": false,
   "definitions": {
-    "file-conditions": {
+    "Rule": {
+      "description": "Filtering rule as regex or string.",
       "anyOf": [
         {
-          "instanceof": "RegExp"
+          "instanceof": "RegExp",
+          "tsType": "RegExp"
         },
         {
-          "type": "string"
+          "type": "string",
+          "minLength": 1
         }
       ]
-    }
-  },
-  "properties": {
-    "test": {
+    },
+    "Rules": {
+      "description": "Filtering rules.",
       "anyOf": [
         {
-          "$ref": "#/definitions/file-conditions"
-        },
-        {
+          "type": "array",
           "items": {
-            "anyOf": [
+            "description": "A rule condition.",
+            "oneOf": [
               {
-                "$ref": "#/definitions/file-conditions"
+                "$ref": "#/definitions/Rule"
               }
             ]
-          },
-          "type": "array"
-        }
-      ]
-    },
-    "include": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/file-conditions"
+          }
         },
         {
-          "items": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/file-conditions"
-              }
-            ]
-          },
-          "type": "array"
+          "$ref": "#/definitions/Rule"
         }
       ]
-    },
-    "exclude": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/file-conditions"
-        },
+    }
+  },
+  "title": "TerserPluginOptions",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "test": {
+      "description": "Include all modules that pass test assertion.",
+      "oneOf": [
         {
-          "items": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/file-conditions"
-              }
-            ]
-          },
-          "type": "array"
+          "$ref": "#/definitions/Rules"
         }
       ]
     },
-    "chunkFilter": {
-      "instanceof": "Function"
-    },
-    "cache": {
-      "anyOf": [
-        {
-          "type": "boolean"
-        },
+    "include": {
+      "description": "Include all modules matching any of these conditions.",
+      "oneOf": [
         {
-          "type": "string"
+          "$ref": "#/definitions/Rules"
         }
       ]
     },
-    "cacheKeys": {
-      "instanceof": "Function"
-    },
-    "parallel": {
-      "anyOf": [
-        {
-          "type": "boolean"
-        },
+    "exclude": {
+      "description": "Exclude all modules matching any of these conditions.",
+      "oneOf": [
         {
-          "type": "integer"
+          "$ref": "#/definitions/Rules"
         }
       ]
     },
-    "sourceMap": {
-      "type": "boolean"
-    },
-    "minify": {
-      "instanceof": "Function"
-    },
     "terserOptions": {
+      "description": "Options for `terser`.",
       "additionalProperties": true,
       "type": "object"
     },
     "extractComments": {
+      "description": "Whether comments shall be extracted to a separate file.",
       "anyOf": [
         {
           "type": "boolean"
         },
         {
-          "type": "string"
+          "type": "string",
+          "minLength": 1
         },
         {
           "instanceof": "RegExp"
@@ -123,7 +91,8 @@
                   "type": "boolean"
                 },
                 {
-                  "type": "string"
+                  "type": "string",
+                  "minLength": 1
                 },
                 {
                   "instanceof": "RegExp"
@@ -136,7 +105,8 @@
             "filename": {
               "anyOf": [
                 {
-                  "type": "string"
+                  "type": "string",
+                  "minLength": 1
                 },
                 {
                   "instanceof": "Function"
@@ -149,7 +119,8 @@
                   "type": "boolean"
                 },
                 {
-                  "type": "string"
+                  "type": "string",
+                  "minLength": 1
                 },
                 {
                   "instanceof": "Function"
@@ -161,9 +132,20 @@
         }
       ]
     },
-    "warningsFilter": {
+    "parallel": {
+      "description": "Use multi-process parallel running to improve the build speed.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "minify": {
+      "description": "Allows you to override default minify function.",
       "instanceof": "Function"
     }
-  },
-  "type": "object"
+  }
 }

test/__snapshots__/validate-options.test.js.snap

@@ -0,0 +1,178 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`validation 1`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.test should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.test should be an array:
+      [RegExp | non-empty string, ...]
+    * options.test should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.test should be an instance of RegExp.
+       * options.test should be a non-empty string."
+`;
+
+exports[`validation 2`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.test should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.test[0] should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.test[0] should be an instance of RegExp.
+       * options.test[0] should be a non-empty string."
+`;
+
+exports[`validation 3`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.include should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.include should be an array:
+      [RegExp | non-empty string, ...]
+    * options.include should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.include should be an instance of RegExp.
+       * options.include should be a non-empty string."
+`;
+
+exports[`validation 4`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.include should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.include[0] should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.include[0] should be an instance of RegExp.
+       * options.include[0] should be a non-empty string."
+`;
+
+exports[`validation 5`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.exclude should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.exclude should be an array:
+      [RegExp | non-empty string, ...]
+    * options.exclude should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.exclude should be an instance of RegExp.
+       * options.exclude should be a non-empty string."
+`;
+
+exports[`validation 6`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.exclude should be one of these:
+   [RegExp | non-empty string, ...] | RegExp | non-empty string
+   -> Filtering rules.
+   Details:
+    * options.exclude[0] should be one of these:
+      RegExp | non-empty string
+      -> Filtering rule as regex or string.
+      Details:
+       * options.exclude[0] should be an instance of RegExp.
+       * options.exclude[0] should be a non-empty string."
+`;
+
+exports[`validation 7`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.parallel should be one of these:
+   boolean | integer
+   -> Use multi-process parallel running to improve the build speed.
+   Details:
+    * options.parallel should be a boolean.
+    * options.parallel should be a integer."
+`;
+
+exports[`validation 8`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.parallel should be one of these:
+   boolean | integer
+   -> Use multi-process parallel running to improve the build speed.
+   Details:
+    * options.parallel should be a boolean.
+    * options.parallel should be a integer."
+`;
+
+exports[`validation 9`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.minify should be an instance of function.
+   -> Allows you to override default minify function."
+`;
+
+exports[`validation 10`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.terserOptions should be an object:
+   object { … }
+   -> Options for \`terser\`."
+`;
+
+exports[`validation 11`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.extractComments should be one of these:
+   boolean | non-empty string | RegExp | function | object { condition?, filename?, banner? }
+   -> Whether comments shall be extracted to a separate file.
+   Details:
+    * options.extractComments.condition should be one of these:
+      boolean | non-empty string | RegExp | function
+      Details:
+       * options.extractComments.condition should be a boolean.
+       * options.extractComments.condition should be a non-empty string.
+       * options.extractComments.condition should be an instance of RegExp.
+       * options.extractComments.condition should be an instance of function."
+`;
+
+exports[`validation 12`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.extractComments should be one of these:
+   boolean | non-empty string | RegExp | function | object { condition?, filename?, banner? }
+   -> Whether comments shall be extracted to a separate file.
+   Details:
+    * options.extractComments.filename should be one of these:
+      non-empty string | function
+      Details:
+       * options.extractComments.filename should be a non-empty string.
+       * options.extractComments.filename should be an instance of function."
+`;
+
+exports[`validation 13`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.extractComments should be one of these:
+   boolean | non-empty string | RegExp | function | object { condition?, filename?, banner? }
+   -> Whether comments shall be extracted to a separate file.
+   Details:
+    * options.extractComments.banner should be one of these:
+      boolean | non-empty string | function
+      Details:
+       * options.extractComments.banner should be a boolean.
+       * options.extractComments.banner should be a non-empty string.
+       * options.extractComments.banner should be an instance of function."
+`;
+
+exports[`validation 14`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options.extractComments has an unknown property 'unknown'. These properties are valid:
+   object { condition?, filename?, banner? }"
+`;
+
+exports[`validation 15`] = `
+"Invalid options object. Terser Plugin has been initialized using an options object that does not match the API schema.
+ - options has an unknown property 'unknown'. These properties are valid:
+   object { test?, include?, exclude?, terserOptions?, extractComments?, parallel?, minify? }"
+`;

test/__snapshots__/worker.test.js.snap

@@ -1,61 +1,177 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`matches snapshot normalizes when options.extractComments is regex: test1.js 1`] = `
+exports[`worker normalizes when minimizerOptions.output.comments is string: all 1`] = `
+Object {
+  "code": "var foo=1;/* hello */
+// Comment
+/* duplicate */
+/* duplicate */",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when minimizerOptions.compress.comments is boolean 1`] = `
 Object {
   "code": "var foo=1;",
-  "error": undefined,
   "extractedComments": Array [],
-  "map": undefined,
-  "warnings": undefined,
 }
 `;
 
-exports[`matches snapshot normalizes when terserOptions.extractComments is number: test4.js 1`] = `
+exports[`worker should match snapshot when minimizerOptions.compress.comments is object 1`] = `
 Object {
   "code": "var foo=1;",
-  "error": undefined,
   "extractedComments": Array [],
-  "map": undefined,
-  "warnings": undefined,
 }
 `;
 
-exports[`matches snapshot normalizes when terserOptions.output.comments is string: all: test2.js 1`] = `
+exports[`worker should match snapshot when minimizerOptions.extractComments is number 1`] = `
 Object {
-  "code": "var foo=1;/* hello */",
-  "error": undefined,
+  "code": "var foo=1;",
   "extractedComments": Array [],
-  "map": undefined,
-  "warnings": undefined,
 }
 `;
 
-exports[`matches snapshot normalizes when terserOptions.output.comments is string: some: test3.js 1`] = `
+exports[`worker should match snapshot when minimizerOptions.mangle is "null" 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when minimizerOptions.mangle is boolean 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when minimizerOptions.mangle is object 1`] = `
+Object {
+  "code": "var a=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when minimizerOptions.output.comments is string: some 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is "all" value 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [
+    "/* hello */",
+    "// Comment",
+    "/* duplicate */",
+  ],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is "false" 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is "some" value 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is "true" 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is "true" 2`] = `
+"var foo = 1;/* hello */
+// Comment
+/* duplicate */
+/* duplicate */"
+`;
+
+exports[`worker should match snapshot when options.extractComments is Function 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [
+    "/* hello */",
+    "// Comment",
+    "/* duplicate */",
+  ],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is Object with "all" value 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [
+    "/* hello */",
+    "// Comment",
+    "/* duplicate */",
+  ],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is Object with "some" value 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is Object with "true" value 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is RegExp 1`] = `
+Object {
+  "code": "var foo=1;",
+  "extractedComments": Array [
+    "/* hello */",
+  ],
+}
+`;
+
+exports[`worker should match snapshot when options.extractComments is empty Object 1`] = `
 Object {
   "code": "var foo=1;",
-  "error": undefined,
   "extractedComments": Array [],
-  "map": undefined,
-  "warnings": undefined,
 }
 `;
 
-exports[`matches snapshot when applied with extract option set to a single file: test5.js 1`] = `
+exports[`worker should match snapshot with extract option set to a single file 1`] = `
 Object {
   "code": "/******/function hello(o){console.log(o)}",
-  "error": undefined,
   "extractedComments": Array [],
-  "map": undefined,
-  "warnings": undefined,
 }
 `;
 
-exports[`matches snapshot when options.inputSourceMap: test6.js 1`] = `
+exports[`worker should match snapshot with options.inputSourceMap 1`] = `
 Object {
   "code": "function foo(f){if(f)return bar()}",
-  "error": undefined,
   "extractedComments": Array [],
-  "map": "{\\"version\\":3,\\"sources\\":[\\"test6.js\\"],\\"names\\":[\\"foo\\",\\"x\\",\\"bar\\"],\\"mappings\\":\\"AAAA,SAASA,IAAIC,GAAK,GAAIA,EAAK,OAAOC\\"}",
-  "warnings": undefined,
+  "map": Object {
+    "mappings": "AAAA,SAASA,IAAIC,GAAK,GAAIA,EAAK,OAAOC",
+    "names": Array [
+      "foo",
+      "x",
+      "bar",
+    ],
+    "sources": Array [
+      "test6.js",
+    ],
+    "version": 3,
+  },
 }
 `;

test/cjs.test.js

@@ -1,8 +1,8 @@
-import TerserPlugin from '../src';
-import CJSTerserPlugin from '../src/cjs';
+import src from "../src";
+import cjs from "../src/cjs";
 
-describe('CJS', () => {
-  it('should exported plugin', () => {
-    expect(CJSTerserPlugin).toEqual(TerserPlugin);
+describe("CJS", () => {
+  it("should export loader", () => {
+    expect(cjs).toEqual(src);
   });
 });

test/exclude-option.test.js

@@ -1,105 +1,73 @@
-import TerserPlugin from '../src/index';
+import path from "path";
 
-import { cleanErrorStack, createCompiler, compile } from './helpers';
+import TerserPlugin from "../src/index";
 
-describe('when applied with `exclude` option', () => {
+import {
+  compile,
+  getCompiler,
+  getErrors,
+  getWarnings,
+  readsAssets,
+} from "./helpers";
+
+describe("exclude option", () => {
   let compiler;
 
   beforeEach(() => {
-    compiler = createCompiler({
+    compiler = getCompiler({
       entry: {
-        excluded1: `${__dirname}/fixtures/excluded1.js`,
-        excluded2: `${__dirname}/fixtures/excluded2.js`,
-        entry: `${__dirname}/fixtures/entry.js`,
+        excluded1: path.resolve(__dirname, "./fixtures/excluded1.js"),
+        excluded2: path.resolve(__dirname, "./fixtures/excluded2.js"),
+        entry: path.resolve(__dirname, "./fixtures/entry.js"),
       },
     });
   });
 
-  it('matches snapshot for a single `exclude` value ({RegExp})', () => {
+  it("should match snapshot for a single RegExp value", async () => {
     new TerserPlugin({
       exclude: /excluded1/i,
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for a single `exclude` value ({String})', () => {
+  it("should match snapshot for a single String value", async () => {
     new TerserPlugin({
-      exclude: 'excluded1',
+      exclude: "excluded1",
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `exclude` values ({RegExp})', () => {
+  it("should match snapshot for multiple RegExp values", async () => {
     new TerserPlugin({
       exclude: [/excluded1/i, /excluded2/i],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `exclude` values ({String})', () => {
+  it("should match snapshot for multiple String values", async () => {
     new TerserPlugin({
-      exclude: ['excluded1', 'excluded2'],
+      exclude: ["excluded1", "excluded2"],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 });

test/fixtures/asset-resource.js

@@ -0,0 +1,7 @@
+import script from './emitted.js'
+
+const myVar = 12;
+
+console.log(myVar, script);
+
+export default 12;

test/fixtures/comments.js

@@ -26,4 +26,6 @@ import('./nested/comments.js');
 * Foo
 */
 
+// @lic
+
 module.exports = Math.random();

test/fixtures/copy.cjs

@@ -0,0 +1,2 @@
+var foo = 12;
+console.log(foo);

test/fixtures/copy.js

@@ -0,0 +1,2 @@
+var foo = 12;
+console.log(foo);

test/fixtures/copy.mjs

@@ -0,0 +1,2 @@
+var foo = 12;
+console.log(foo);

test/fixtures/emit-loader.js

@@ -0,0 +1,5 @@
+module.exports = function(content) {
+  this.emitFile("extra-file.js", 'var a = 1; console.log(a);');
+
+  return content;
+};

test/fixtures/emitted.js

@@ -0,0 +1 @@
+console.log('HERE');

test/fixtures/entry.mjs

@@ -1,9 +1,12 @@
 // foo
-/* @preserve*/
 // bar
 const a = 2 + 2;
 
-module.exports = function Foo() {
+function test() {
   const b = 2 + 2;
-  console.log(b + 1 + 2);
-};
+  console.log(b + 1 + 2 + a);
+}
+
+test();
+
+module.exports = test;

test/fixtures/file-loader.js

@@ -0,0 +1,7 @@
+import script from '!!file-loader?name=[path][name].[ext]!./emitted.js'
+
+const myVar = 12;
+
+console.log(myVar, script);
+
+export default 12;

test/fixtures/file.js

@@ -0,0 +1 @@
+module.exports = "ok";

test/fixtures/file.worker.js

@@ -0,0 +1,7 @@
+/*! Legal Comment 1 */
+
+/*! Legal Comment 2 */
+
+/*! Legal Comment 3 */
+
+onmessage = function (event) {};

test/fixtures/import-export/entry.js

@@ -12,4 +12,6 @@ function Foo() {
   };
 }
 
+console.log(Foo());
+
 export default Foo;

test/fixtures/minify/es6.js

@@ -12,4 +12,6 @@ class Point {
   }
 }
 
+console.log('HERE');
+
 export default Point;

test/fixtures/shebang-1.js

@@ -0,0 +1 @@
+console.log('HERE');

test/fixtures/shebang.js

@@ -0,0 +1,3 @@
+/* Comment */
+/*! Legal Comment */
+console.log('HERE');

test/fixtures/worker-loader.js

@@ -0,0 +1,10 @@
+/*! Legal Comment */
+
+import Worker from './file.worker.js';
+
+const worker = new Worker();
+
+worker.postMessage({ a: 1 });
+worker.onmessage = function (event) {};
+
+worker.addEventListener('message', function (event) {});

test/helpers/BrokenCodePlugin.js

@@ -0,0 +1,16 @@
+import webpack from "webpack";
+
+export default class BrokenCodePlugin {
+  apply(compiler) {
+    const plugin = { name: this.constructor.name };
+
+    compiler.hooks.thisCompilation.tap(plugin, (compilation) => {
+      compilation.hooks.additionalAssets.tap(plugin, () => {
+        // eslint-disable-next-line no-param-reassign
+        compilation.assets["broken.js"] = new webpack.sources.RawSource(
+          "`Broken==="
+        );
+      });
+    });
+  }
+}

test/helpers/EmitNewAsset.js

@@ -0,0 +1,31 @@
+export default class EmitNewAsset {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    const pluginName = this.constructor.name;
+
+    const { RawSource } = compiler.webpack.sources;
+
+    compiler.hooks.compilation.tap(pluginName, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: pluginName,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT,
+        },
+        () => {
+          // eslint-disable-next-line no-param-reassign
+          compilation.emitAsset(
+            this.options.name,
+            new RawSource(`
+var foo =    'bar';
+
+var bar    = 'foo';
+            `)
+          );
+        }
+      );
+    });
+  }
+}

test/helpers/ExistingCommentsFile.js

@@ -0,0 +1,16 @@
+import webpack from "webpack";
+
+export default class ExistingCommentsFile {
+  apply(compiler) {
+    const plugin = { name: this.constructor.name };
+
+    compiler.hooks.thisCompilation.tap(plugin, (compilation) => {
+      compilation.hooks.additionalAssets.tap(plugin, () => {
+        // eslint-disable-next-line no-param-reassign
+        compilation.assets["licenses.txt"] = new webpack.sources.RawSource(
+          "// Existing Comment"
+        );
+      });
+    });
+  }
+}

test/helpers/ModifyExistingAsset.js

@@ -0,0 +1,24 @@
+import webpack from "webpack";
+
+export default class ExistingCommentsFile {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    const plugin = { name: this.constructor.name };
+
+    compiler.hooks.thisCompilation.tap(plugin, (compilation) => {
+      compilation.hooks.additionalAssets.tap(plugin, () => {
+        // eslint-disable-next-line no-param-reassign
+        compilation.assets[this.options.name] =
+          new webpack.sources.ConcatSource(
+            `function changed() {} ${
+              this.options.comment ? "/*! CHANGED */" : ""
+            }`,
+            compilation.assets[this.options.name]
+          );
+      });
+    });
+  }
+}

test/helpers/compile.js

@@ -0,0 +1,10 @@
+export default (compiler) =>
+  new Promise((resolve, reject) => {
+    compiler.run((error, stats) => {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(stats);
+    });
+  });

test/helpers/countPlugins.js

@@ -0,0 +1,9 @@
+export default function countPlugins({ hooks }) {
+  return Object.keys(hooks).reduce((aggregate, name) => {
+    // eslint-disable-next-line no-param-reassign
+    aggregate[name] = Array.isArray(hooks[name].taps)
+      ? hooks[name].taps.length
+      : 0;
+    return aggregate;
+  }, {});
+}

test/helpers/execute.js

@@ -0,0 +1,22 @@
+import Module from "module";
+import path from "path";
+
+const parentModule = module;
+
+export default (code) => {
+  const resource = "test.js";
+  const module = new Module(resource, parentModule);
+  // eslint-disable-next-line no-underscore-dangle
+  module.paths = Module._nodeModulePaths(
+    path.resolve(__dirname, "../fixtures")
+  );
+  module.filename = resource;
+
+  // eslint-disable-next-line no-underscore-dangle
+  module._compile(
+    `let __export__;${code};module.exports = __export__;`,
+    resource
+  );
+
+  return module.exports;
+};

test/helpers/getCompiler.js

@@ -0,0 +1,31 @@
+import path from "path";
+
+import webpack from "webpack";
+import { createFsFromVolume, Volume } from "memfs";
+
+export default function getCompiler(options = {}) {
+  const compiler = webpack(
+    Array.isArray(options)
+      ? options
+      : {
+          mode: "production",
+          bail: true,
+          entry: path.resolve(__dirname, "../fixtures/entry.js"),
+          optimization: {
+            minimize: false,
+          },
+          output: {
+            pathinfo: false,
+            path: path.resolve(__dirname, "dist"),
+            filename: "[name].js",
+            chunkFilename: "[id].[name].js",
+          },
+          plugins: [],
+          ...options,
+        }
+  );
+
+  compiler.outputFileSystem = createFsFromVolume(new Volume());
+
+  return compiler;
+}

test/helpers/getErrors.js

@@ -0,0 +1,3 @@
+import normalizeErrors from "./normalizeErrors";
+
+export default (stats) => normalizeErrors(stats.compilation.errors).sort();

test/helpers/getWarnings.js

@@ -0,0 +1,3 @@
+import normalizeErrors from "./normalizeErrors";
+
+export default (stats) => normalizeErrors(stats.compilation.warnings).sort();

test/helpers/index.js

@@ -0,0 +1,29 @@
+import BrokenCodePlugin from "./BrokenCodePlugin";
+import compile from "./compile";
+import countPlugins from "./countPlugins";
+import EmitNewAsset from "./EmitNewAsset";
+import execute from "./execute";
+import ExistingCommentsFile from "./ExistingCommentsFile";
+import getCompiler from "./getCompiler";
+import getErrors from "./getErrors";
+import getWarnings from "./getWarnings";
+import ModifyExistingAsset from "./ModifyExistingAsset";
+import readAsset from "./readAsset";
+import readsAssets from "./readAssets";
+import normalizeErrors from "./normalizeErrors";
+
+export {
+  BrokenCodePlugin,
+  compile,
+  countPlugins,
+  EmitNewAsset,
+  ExistingCommentsFile,
+  execute,
+  getCompiler,
+  getErrors,
+  getWarnings,
+  ModifyExistingAsset,
+  normalizeErrors,
+  readAsset,
+  readsAssets,
+};

test/helpers/normalizeErrors.js

@@ -0,0 +1,18 @@
+function removeCWD(str) {
+  const isWin = process.platform === "win32";
+  let cwd = process.cwd();
+
+  if (isWin) {
+    // eslint-disable-next-line no-param-reassign
+    str = str.replace(/\\/g, "/");
+    // eslint-disable-next-line no-param-reassign
+    cwd = cwd.replace(/\\/g, "/");
+  }
+
+  return str.replace(new RegExp(cwd, "g"), "");
+}
+
+export default (errors) =>
+  errors.map((error) =>
+    removeCWD(error.toString().split("\n").slice(0, 2).join("\n"))
+  );

test/helpers/readAsset.js

@@ -0,0 +1,23 @@
+import path from "path";
+
+export default (asset, compiler, stats) => {
+  const usedFs = compiler.outputFileSystem;
+  const outputPath = stats.compilation.outputOptions.path;
+
+  let data = "";
+  let targetFile = asset;
+
+  const queryStringIdx = targetFile.indexOf("?");
+
+  if (queryStringIdx >= 0) {
+    targetFile = targetFile.substr(0, queryStringIdx);
+  }
+
+  try {
+    data = usedFs.readFileSync(path.join(outputPath, targetFile)).toString();
+  } catch (error) {
+    data = error.toString();
+  }
+
+  return data;
+};

test/helpers/readAssets.js

@@ -0,0 +1,11 @@
+import readAsset from "./readAsset";
+
+export default function readAssets(compiler, stats) {
+  const assets = {};
+
+  Object.keys(stats.compilation.assets).forEach((asset) => {
+    assets[asset] = readAsset(asset, compiler, stats);
+  });
+
+  return assets;
+}

test/helpers/snapshotResolver.js

@@ -0,0 +1,28 @@
+const path = require("path");
+
+const webpack = require("webpack");
+
+// eslint-disable-next-line global-require
+const [webpackVersion] = webpack.version;
+const snapshotExtension = `.snap.webpack${webpackVersion}`;
+
+// eslint-disable-next-line no-console
+console.log("Current webpack version:", webpackVersion);
+
+module.exports = {
+  resolveSnapshotPath: (testPath) =>
+    path.join(
+      path.dirname(testPath),
+      "__snapshots__",
+      `${path.basename(testPath)}${snapshotExtension}`
+    ),
+  resolveTestPath: (snapshotPath) =>
+    snapshotPath
+      .replace(`${path.sep}__snapshots__`, "")
+      .slice(0, -snapshotExtension.length),
+  testPathForConsistencyCheck: path.join(
+    "consistency_check",
+    "__tests__",
+    "example.test.js"
+  ),
+};

test/include-option.test.js

@@ -1,105 +1,73 @@
-import TerserPlugin from '../src/index';
+import path from "path";
 
-import { cleanErrorStack, createCompiler, compile } from './helpers';
+import TerserPlugin from "../src/index";
 
-describe('when applied with `include` option', () => {
+import {
+  compile,
+  getCompiler,
+  getErrors,
+  getWarnings,
+  readsAssets,
+} from "./helpers";
+
+describe("include option", () => {
   let compiler;
 
   beforeEach(() => {
-    compiler = createCompiler({
+    compiler = getCompiler({
       entry: {
-        included1: `${__dirname}/fixtures/included1.js`,
-        included2: `${__dirname}/fixtures/included2.js`,
-        entry: `${__dirname}/fixtures/entry.js`,
+        included1: path.resolve(__dirname, "./fixtures/included1.js"),
+        included2: path.resolve(__dirname, "./fixtures/included2.js"),
+        entry: path.resolve(__dirname, "./fixtures/entry.js"),
       },
     });
   });
 
-  it('matches snapshot for a single `include` value ({RegExp})', () => {
+  it("should match snapshot for a single RegExp value", async () => {
     new TerserPlugin({
       include: /included1/i,
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for a single `include` value ({String})', () => {
+  it("should match snapshot for a single String value", async () => {
     new TerserPlugin({
-      include: 'included1',
+      include: "included1",
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `include` values  ({RegExp})', () => {
+  it("should match snapshot for multiple RegExp values", async () => {
     new TerserPlugin({
       include: [/included1/i, /included2/i],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `include` values  ({String})', () => {
+  it("should match snapshot for multiple String values", async () => {
     new TerserPlugin({
-      include: ['included1', 'included2'],
+      include: ["included1", "included2"],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 });

test/parallel-option.test.js

@@ -1,128 +1,262 @@
-import os from 'os';
+import path from "path";
+import os from "os";
 
-import workerFarm from 'worker-farm';
+import { Worker } from "jest-worker";
 
-import TerserPlugin from '../src/index';
+import TerserPlugin from "../src/index";
 
-import { createCompiler, compile, cleanErrorStack } from './helpers';
+import {
+  compile,
+  getCompiler,
+  getErrors,
+  getWarnings,
+  readsAssets,
+} from "./helpers";
 
-jest.mock('os', () => {
-  const actualOs = require.requireActual('os');
+jest.mock("os", () => {
+  const actualOs = jest.requireActual("os");
 
-  actualOs.cpus = jest.fn(() => {
-    return { length: 4 };
-  });
+  const mocked = {
+    cpus: jest.fn(() => {
+      return { length: 4 };
+    }),
+  };
 
-  return actualOs;
+  return { ...actualOs, ...mocked };
 });
 
 // Based on https://github.com/facebook/jest/blob/edde20f75665c2b1e3c8937f758902b5cf28a7b4/packages/jest-runner/src/__tests__/test_runner.test.js
-let workerFarmMock;
+let workerTransform;
+let workerEnd;
+
+const ENABLE_WORKER_THREADS =
+  typeof process.env.ENABLE_WORKER_THREADS !== "undefined"
+    ? process.env.ENABLE_WORKER_THREADS === "true"
+    : true;
 
-jest.mock('worker-farm', () => {
-  const mock = jest.fn(
-    (options, worker) =>
-      (workerFarmMock = jest.fn((data, callback) =>
+jest.mock("jest-worker", () => {
+  return {
+    Worker: jest.fn().mockImplementation((workerPath) => {
+      return {
         // eslint-disable-next-line global-require, import/no-dynamic-require
-        require(worker)(data, callback)
-      ))
-  );
-  mock.end = jest.fn();
-  return mock;
+        transform: (workerTransform = jest.fn((data) =>
+          // eslint-disable-next-line global-require, import/no-dynamic-require
+          require(workerPath).transform(data)
+        )),
+        end: (workerEnd = jest.fn()),
+        getStderr: jest.fn(),
+        getStdout: jest.fn(),
+      };
+    }),
+  };
 });
 
-describe('when applied with `parallel` option', () => {
+const workerPath = require.resolve("../src/minify");
+
+describe("parallel option", () => {
   let compiler;
 
   beforeEach(() => {
-    os.cpus.mockClear();
-    workerFarm.mockClear();
-    workerFarm.end.mockClear();
+    jest.clearAllMocks();
 
-    compiler = createCompiler({
+    compiler = getCompiler({
       entry: {
-        one: `${__dirname}/fixtures/entry.js`,
-        two: `${__dirname}/fixtures/entry.js`,
-        three: `${__dirname}/fixtures/entry.js`,
-        four: `${__dirname}/fixtures/entry.js`,
+        one: path.resolve(__dirname, "./fixtures/entry.js"),
+        two: path.resolve(__dirname, "./fixtures/entry.js"),
+        three: path.resolve(__dirname, "./fixtures/entry.js"),
+        four: path.resolve(__dirname, "./fixtures/entry.js"),
       },
     });
   });
 
-  it('matches snapshot for `false` value', () => {
+  it("should match snapshot when a value is not specify", async () => {
+    new TerserPlugin().apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: os.cpus().length - 1,
+    });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
+  });
+
+  it('should match snapshot for the "false" value', async () => {
     new TerserPlugin({ parallel: false }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(0);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
+  });
+
+  it('should match snapshot for the "true" value', async () => {
+    new TerserPlugin({ parallel: true }).apply(compiler);
+
+    const stats = await compile(compiler);
 
-      expect(workerFarm.mock.calls.length).toBe(0);
-      expect(workerFarm.end.mock.calls.length).toBe(0);
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: Math.min(4, os.cpus().length - 1),
+    });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
+  });
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
+  it('should match snapshot for the "2" value', async () => {
+    new TerserPlugin({ parallel: 2 }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: 2,
     });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for `true` value', () => {
+  it('should match snapshot for the "true" value when only one file passed', async () => {
+    compiler = getCompiler({
+      entry: path.resolve(__dirname, "./fixtures/entry.js"),
+    });
+
     new TerserPlugin({ parallel: true }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(workerFarm.mock.calls.length).toBe(1);
-      expect(workerFarm.mock.calls[0][0].maxConcurrentWorkers).toBe(
-        os.cpus().length - 1
-      );
-      expect(workerFarmMock.mock.calls.length).toBe(
-        Object.keys(stats.compilation.assets).length
-      );
-      expect(workerFarm.end.mock.calls.length).toBe(1);
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: Math.min(1, os.cpus().length - 1),
     });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for `2` value (number)', () => {
-    new TerserPlugin({ parallel: 2 }).apply(compiler);
+  it('should match snapshot for the "true" value and the number of files is less than the number of cores', async () => {
+    const entries = {};
+
+    for (let i = 0; i < os.cpus().length / 2; i++) {
+      entries[`entry-${i}`] = path.resolve(__dirname, "./fixtures/entry.js");
+    }
+
+    compiler = getCompiler({ entry: entries });
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(workerFarm.mock.calls.length).toBe(1);
-      expect(workerFarm.mock.calls[0][0].maxConcurrentWorkers).toBe(2);
-      expect(workerFarmMock.mock.calls.length).toBe(
-        Object.keys(stats.compilation.assets).length
-      );
-      expect(workerFarm.end.mock.calls.length).toBe(1);
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
+    new TerserPlugin({ parallel: true }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: Math.min(Object.keys(entries).length, os.cpus().length - 1),
+    });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
+  });
+
+  it('should match snapshot for the "true" value and the number of files is same than the number of cores', async () => {
+    const entries = {};
+
+    for (let i = 0; i < os.cpus().length; i++) {
+      entries[`entry-${i}`] = path.resolve(__dirname, "./fixtures/entry.js");
+    }
+
+    compiler = getCompiler({ entry: entries });
+
+    new TerserPlugin({ parallel: true }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: Math.min(Object.keys(entries).length, os.cpus().length - 1),
     });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
+  });
+
+  it('should match snapshot for the "true" value and the number of files is more than the number of cores', async () => {
+    const entries = {};
+
+    for (let i = 0; i < os.cpus().length * 2; i++) {
+      entries[`entry-${i}`] = path.resolve(__dirname, "./fixtures/entry.js");
+    }
+
+    compiler = getCompiler({
+      entry: {
+        one: path.resolve(__dirname, "./fixtures/entry.js"),
+        two: path.resolve(__dirname, "./fixtures/entry.js"),
+        three: path.resolve(__dirname, "./fixtures/entry.js"),
+        four: path.resolve(__dirname, "./fixtures/entry.js"),
+        five: path.resolve(__dirname, "./fixtures/entry.js"),
+        six: path.resolve(__dirname, "./fixtures/entry.js"),
+        seven: path.resolve(__dirname, "./fixtures/entry.js"),
+        eight: path.resolve(__dirname, "./fixtures/entry.js"),
+      },
+    });
+
+    new TerserPlugin({ parallel: true }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(Worker).toHaveBeenCalledTimes(1);
+    expect(Worker).toHaveBeenLastCalledWith(workerPath, {
+      enableWorkerThreads: ENABLE_WORKER_THREADS,
+      numWorkers: Math.min(Object.keys(entries).length, os.cpus().length - 1),
+    });
+    expect(workerTransform).toHaveBeenCalledTimes(
+      Object.keys(stats.compilation.assets).length
+    );
+    expect(workerEnd).toHaveBeenCalledTimes(1);
+
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 });

test/test-option.test.js

@@ -1,165 +1,125 @@
-import TerserPlugin from '../src/index';
+import path from "path";
 
-import { cleanErrorStack, createCompiler, compile } from './helpers';
+import TerserPlugin from "../src/index";
 
-describe('when applied with `test` option', () => {
+import {
+  compile,
+  getCompiler,
+  getErrors,
+  getWarnings,
+  readsAssets,
+} from "./helpers";
+
+describe("test option", () => {
   let compiler;
 
   beforeEach(() => {
-    compiler = createCompiler({
+    compiler = getCompiler({
       entry: {
-        js: `${__dirname}/fixtures/entry.js`,
-        mjs: `${__dirname}/fixtures/entry.mjs`,
-        importExport: `${__dirname}/fixtures/import-export/entry.js`,
-        AsyncImportExport: `${__dirname}/fixtures/async-import-export/entry.js`,
+        js: path.resolve(__dirname, "./fixtures/entry.js"),
+        mjs: path.resolve(__dirname, "./fixtures/entry.mjs"),
+        importExport: path.resolve(
+          __dirname,
+          "./fixtures/import-export/entry.js"
+        ),
+        AsyncImportExport: path.resolve(
+          __dirname,
+          "./fixtures/async-import-export/entry.js"
+        ),
       },
       output: {
-        path: `${__dirname}/dist`,
-        filename: '[name].js?var=[hash]',
-        chunkFilename: '[id].[name].js?ver=[hash]',
+        path: path.resolve(__dirname, "./dist"),
+        filename: `[name].js?var=[fullhash]`,
+        chunkFilename: `[id].[name].js?ver=[fullhash]`,
       },
     });
   });
 
-  it('matches snapshot with empty value', () => {
+  it("should match snapshot with empty value", async () => {
     new TerserPlugin().apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for a single `test` value ({RegExp})', () => {
+  it("should match snapshot for a single `test` value ({RegExp})", async () => {
     new TerserPlugin({
       test: /(m)?js\.js(\?.*)?$/i,
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for a single `test` value ({String})', () => {
+  it('should match snapshot for a single "test" value ({String})', async () => {
     new TerserPlugin({
-      test: 'js.js',
+      test: "js.js",
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `test` values ({RegExp})', () => {
+  it('should match snapshot for multiple "test" values ({RegExp})', async () => {
     new TerserPlugin({
       test: [/(m)?js\.js(\?.*)?$/i, /AsyncImportExport\.js(\?.*)?$/i],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
+    const stats = await compile(compiler);
 
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
-
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot for multiple `test` values ({String})', () => {
+  it('should match snapshot for multiple "test" values ({String})', async () => {
     new TerserPlugin({
-      test: ['js.js', 'AsyncImportExport.js'],
+      test: ["js.js", "AsyncImportExport.js"],
     }).apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
-  it('matches snapshot and uglify `mjs`', () => {
-    compiler = createCompiler({
+  it('should match snapshot and uglify "mjs"', async () => {
+    compiler = getCompiler({
       entry: {
-        js: `${__dirname}/fixtures/entry.js`,
-        mjs: `${__dirname}/fixtures/entry.mjs`,
-        importExport: `${__dirname}/fixtures/import-export/entry.js`,
-        AsyncImportExport: `${__dirname}/fixtures/async-import-export/entry.js`,
+        js: path.resolve(__dirname, "./fixtures/entry.js"),
+        mjs: path.resolve(__dirname, "./fixtures/entry.mjs"),
+        importExport: path.resolve(
+          __dirname,
+          "./fixtures/import-export/entry.js"
+        ),
+        AsyncImportExport: path.resolve(
+          __dirname,
+          "./fixtures/async-import-export/entry.js"
+        ),
       },
       output: {
-        path: `${__dirname}/dist`,
-        filename: '[name].mjs?var=[hash]',
-        chunkFilename: '[id].[name].mjs?ver=[hash]',
+        path: path.resolve(__dirname, "./dist"),
+        filename: `[name].mjs?var=[fullhash]`,
+        chunkFilename: `[id].[name].mjs?ver=[fullhash]`,
       },
     });
 
     new TerserPlugin().apply(compiler);
 
-    return compile(compiler).then((stats) => {
-      const errors = stats.compilation.errors.map(cleanErrorStack);
-      const warnings = stats.compilation.warnings.map(cleanErrorStack);
-
-      expect(errors).toMatchSnapshot('errors');
-      expect(warnings).toMatchSnapshot('warnings');
+    const stats = await compile(compiler);
 
-      for (const file in stats.compilation.assets) {
-        if (
-          Object.prototype.hasOwnProperty.call(stats.compilation.assets, file)
-        ) {
-          expect(stats.compilation.assets[file].source()).toMatchSnapshot(file);
-        }
-      }
-    });
+    expect(readsAssets(compiler, stats)).toMatchSnapshot("assets");
+    expect(getErrors(stats)).toMatchSnapshot("errors");
+    expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 });

test/validation.test.js → test/validate-options.test.js

@@ -1,13 +1,13 @@
-import TerserPlugin from '../src';
+import TerserPlugin from "../src";
 
-it('validation', () => {
+it("validation", () => {
   /* eslint-disable no-new */
   expect(() => {
     new TerserPlugin({ test: /foo/ });
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ test: 'foo' });
+    new TerserPlugin({ test: "foo" });
   }).not.toThrow();
 
   expect(() => {
@@ -19,11 +19,11 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ test: ['foo', 'bar'] });
+    new TerserPlugin({ test: ["foo", "bar"] });
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ test: [/foo/, 'bar'] });
+    new TerserPlugin({ test: [/foo/, "bar"] });
   }).not.toThrow();
 
   expect(() => {
@@ -39,7 +39,7 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ include: 'foo' });
+    new TerserPlugin({ include: "foo" });
   }).not.toThrow();
 
   expect(() => {
@@ -51,11 +51,11 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ include: ['foo', 'bar'] });
+    new TerserPlugin({ include: ["foo", "bar"] });
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ include: [/foo/, 'bar'] });
+    new TerserPlugin({ include: [/foo/, "bar"] });
   }).not.toThrow();
 
   expect(() => {
@@ -71,7 +71,7 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ exclude: 'foo' });
+    new TerserPlugin({ exclude: "foo" });
   }).not.toThrow();
 
   expect(() => {
@@ -83,11 +83,11 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ exclude: ['foo', 'bar'] });
+    new TerserPlugin({ exclude: ["foo", "bar"] });
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ exclude: [/foo/, 'bar'] });
+    new TerserPlugin({ exclude: [/foo/, "bar"] });
   }).not.toThrow();
 
   expect(() => {
@@ -98,38 +98,6 @@ it('validation', () => {
     new TerserPlugin({ exclude: [true] });
   }).toThrowErrorMatchingSnapshot();
 
-  expect(() => {
-    new TerserPlugin({ chunkFilter: () => {} });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ chunkFilter: true });
-  }).toThrowErrorMatchingSnapshot();
-
-  expect(() => {
-    new TerserPlugin({ cache: true });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ cache: false });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ cache: 'path/to/cache/directory' });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ cache: {} });
-  }).toThrowErrorMatchingSnapshot();
-
-  expect(() => {
-    new TerserPlugin({ cacheKeys() {} });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ cacheKeys: 'test' });
-  }).toThrowErrorMatchingSnapshot();
-
   expect(() => {
     new TerserPlugin({ parallel: true });
   }).not.toThrow();
@@ -143,25 +111,13 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ parallel: '2' });
+    new TerserPlugin({ parallel: "2" });
   }).toThrowErrorMatchingSnapshot();
 
   expect(() => {
     new TerserPlugin({ parallel: {} });
   }).toThrowErrorMatchingSnapshot();
 
-  expect(() => {
-    new TerserPlugin({ sourceMap: true });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ sourceMap: false });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ sourceMap: 'true' });
-  }).toThrowErrorMatchingSnapshot();
-
   expect(() => {
     new TerserPlugin({ minify() {} });
   }).not.toThrow();
@@ -183,7 +139,6 @@ it('validation', () => {
       terserOptions: {
         // eslint-disable-next-line no-undefined
         ecma: undefined,
-        warnings: false,
         parse: {},
         compress: {},
         mangle: true,
@@ -212,7 +167,7 @@ it('validation', () => {
   }).not.toThrow();
 
   expect(() => {
-    new TerserPlugin({ extractComments: 'comment' });
+    new TerserPlugin({ extractComments: "comment" });
   }).not.toThrow();
 
   expect(() => {
@@ -234,7 +189,7 @@ it('validation', () => {
   expect(() => {
     new TerserPlugin({
       extractComments: {
-        condition: 'comment',
+        condition: "comment",
       },
     });
   }).not.toThrow();
@@ -266,7 +221,7 @@ it('validation', () => {
   expect(() => {
     new TerserPlugin({
       extractComments: {
-        filename: 'test.js',
+        filename: "test.js",
       },
     });
   }).not.toThrow();
@@ -298,7 +253,7 @@ it('validation', () => {
   expect(() => {
     new TerserPlugin({
       extractComments: {
-        banner: 'banner',
+        banner: "banner",
       },
     });
   }).not.toThrow();
@@ -323,14 +278,6 @@ it('validation', () => {
     new TerserPlugin({ extractComments: { unknown: true } });
   }).toThrowErrorMatchingSnapshot();
 
-  expect(() => {
-    new TerserPlugin({ warningsFilter() {} });
-  }).not.toThrow();
-
-  expect(() => {
-    new TerserPlugin({ warningsFilter: true });
-  }).toThrowErrorMatchingSnapshot();
-
   expect(() => {
     new TerserPlugin({ unknown: true });
   }).toThrowErrorMatchingSnapshot();

test/worker.test.js

@@ -1,118 +1,301 @@
-import serialize from 'serialize-javascript';
+import serialize from "serialize-javascript";
 
-import worker from '../src/worker';
+import { transform } from "../src/minify";
 
-describe('matches snapshot', () => {
-  it('normalizes when options.extractComments is regex', () => {
+describe("worker", () => {
+  it('should match snapshot when options.extractComments is "false"', async () => {
     const options = {
-      file: 'test1.js',
-      input: 'var foo = 1;/* hello */',
-      extractComments: /foo/,
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: false,
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is "true"', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: true,
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when options.extractComments is RegExp", async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: /hello/,
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when options.extractComments is Function", async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: () => true,
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when options.extractComments is empty Object", async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: {},
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is Object with "true" value', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: {
+        condition: true,
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is Object with "some" value', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: {
+        condition: "some",
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is Object with "all" value', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: {
+        condition: "all",
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is "all" value', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: "all",
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 
-  it('normalizes when terserOptions.output.comments is string: all', () => {
+  it('should match snapshot when options.extractComments is "some" value', async () => {
     const options = {
-      file: 'test2.js',
-      input: 'var foo = 1;/* hello */',
-      terserOptions: {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      extractComments: "some",
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("normalizes when minimizerOptions.output.comments is string: all", async () => {
+    const options = {
+      name: "test2.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
         output: {
-          comments: 'all',
+          comments: "all",
         },
       },
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when minimizerOptions.compress.comments is boolean", async () => {
+    const options = {
+      name: "test3.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
+        compress: true,
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 
-  it('normalizes when terserOptions.output.comments is string: some', () => {
+  it("should match snapshot when minimizerOptions.compress.comments is object", async () => {
     const options = {
-      file: 'test3.js',
-      input: 'var foo = 1;/* hello */',
-      terserOptions: {
+      name: "test3.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
+        compress: {
+          passes: 2,
+        },
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when minimizerOptions.output.comments is string: some", async () => {
+    const options = {
+      name: "test3.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
         output: {
-          comments: 'some',
+          comments: "some",
         },
       },
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 
-  it('normalizes when terserOptions.extractComments is number', () => {
+  it("should match snapshot when minimizerOptions.extractComments is number", async () => {
     const options = {
-      file: 'test4.js',
-      input: 'var foo = 1;/* hello */',
-      terserOptions: {
+      name: "test4.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
         output: {
-          comments: 'some',
+          comments: "some",
         },
       },
       extractComments: 1,
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 
-  it('when applied with extract option set to a single file', () => {
+  it("should match snapshot with extract option set to a single file", async () => {
     const options = {
-      file: 'test5.js',
-      input: '/******/ function hello(a) {console.log(a)}',
-      terserOptions: {
+      name: "test5.js",
+      input: "/******/ function hello(a) {console.log(a)}",
+      minifyOptions: {
         output: {
-          comments: 'all',
+          comments: "all",
         },
       },
       extractComments: {
-        condition: 'should be extracted',
-        // TODO https://github.com/yahoo/serialize-javascript/issues/44
-        // filename: (file) => file.replace(/(\.\w+)$/, '.license$1'),
+        condition: "should be extracted",
+        filename: (file) => file.filename.replace(/(\.\w+)$/, ".license$1"),
         banner: (licenseFile) =>
           `License information can be found in ${licenseFile}`,
       },
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 
-  it('when options.inputSourceMap', () => {
+  it("should match snapshot with options.inputSourceMap", async () => {
     const options = {
-      file: 'test6.js',
-      input: 'function foo(x) { if (x) { return bar(); not_called1(); } }',
+      name: "test6.js",
+      input: "function foo(x) { if (x) { return bar(); not_called1(); } }",
       inputSourceMap: {
         version: 3,
-        sources: ['test1.js'],
-        names: ['foo', 'x', 'bar', 'not_called1'],
-        mappings: 'AAAA,QAASA,KAAIC,GACT,GAAIA,EAAG,CACH,MAAOC,MACPC',
+        sources: ["test1.js"],
+        names: ["foo", "x", "bar", "not_called1"],
+        mappings: "AAAA,QAASA,KAAIC,GACT,GAAIA,EAAG,CACH,MAAOC,MACPC",
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when options.extractComments is "true"', async () => {
+    const options = {
+      name: "test1.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minify: (item) => item["test1.js"],
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it('should match snapshot when minimizerOptions.mangle is "null"', async () => {
+    const options = {
+      name: "test4.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
+        mangle: null,
       },
     };
-    worker(serialize(options), (error, data) => {
-      if (error) {
-        throw error;
-      }
-      expect(data).toMatchSnapshot(options.file);
-    });
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when minimizerOptions.mangle is boolean", async () => {
+    const options = {
+      name: "test4.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
+        mangle: true,
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
+  });
+
+  it("should match snapshot when minimizerOptions.mangle is object", async () => {
+    const options = {
+      name: "test4.js",
+      input:
+        "var foo = 1;/* hello */\n// Comment\n/* duplicate */\n/* duplicate */",
+      minifyOptions: {
+        mangle: { toplevel: true },
+      },
+    };
+    const workerResult = await transform(serialize(options));
+
+    expect(workerResult).toMatchSnapshot();
   });
 });

tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "moduleResolution": "node",
+    "allowJs": true,
+    "checkJs": true,
+    "strict": true,
+    "types": ["node"],
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["./src/**/*"]
+}