webpack 4.25.1 → 4.27.1

package/buildin/global.js

@@ -7,7 +7,7 @@ g = (function() {
 
 try {
 	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("this");
+	g = g || new Function("return this")();
 } catch (e) {
 	// This works if the window reference is available
 	if (typeof window === "object") g = window;

package/declarations/WebpackOptions.d.ts

@@ -225,6 +225,7 @@ export type ArrayOfStringOrStringArrayValues = (string | string[])[];
  * via the `definition` "WebpackPluginFunction".
  */
 export type WebpackPluginFunction = (
+	this: import("../lib/Compiler"),
 	compiler: import("../lib/Compiler")
 ) => void;
 /**

package/lib/Chunk.js

@@ -430,7 +430,7 @@ class Chunk {
 	}
 
 	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of, and then chunk raphi twil=
+	 * @param {Chunk} newChunk the new chunk that will be split out of the current chunk
 	 * @returns {void}
 	 */
 	split(newChunk) {
@@ -454,6 +454,10 @@ class Chunk {
 	}
 
 	canBeIntegrated(otherChunk) {
+		if (this.preventIntegration || otherChunk.preventIntegration) {
+			return false;
+		}
+
 		const isAvailable = (a, b) => {
 			const queue = new Set(b.groupsIterable);
 			for (const chunkGroup of queue) {
@@ -466,14 +470,13 @@ class Chunk {
 			return true;
 		};
 
-		if (this.preventIntegration || otherChunk.preventIntegration) {
-			return false;
-		}
+		const selfHasRuntime = this.hasRuntime();
+		const otherChunkHasRuntime = otherChunk.hasRuntime();
 
-		if (this.hasRuntime() !== otherChunk.hasRuntime()) {
-			if (this.hasRuntime()) {
+		if (selfHasRuntime !== otherChunkHasRuntime) {
+			if (selfHasRuntime) {
 				return isAvailable(this, otherChunk);
-			} else if (otherChunk.hasRuntime()) {
+			} else if (otherChunkHasRuntime) {
 				return isAvailable(otherChunk, this);
 			} else {
 				return false;

package/lib/FlagDependencyExportsPlugin.js

@@ -32,6 +32,7 @@ class FlagDependencyExportsPlugin {
 						let module;
 						let moduleWithExports;
 						let moduleProvidedExports;
+						let providedExportsAreTemporary;
 
 						const processDependenciesBlock = depBlock => {
 							for (const dep of depBlock.dependencies) {
@@ -72,6 +73,7 @@ class FlagDependencyExportsPlugin {
 							// store dependencies
 							const exportDeps = exportDesc.dependencies;
 							if (exportDeps) {
+								providedExportsAreTemporary = true;
 								for (const exportDependency of exportDeps) {
 									// add dependency for this module
 									const set = dependencies.get(exportDependency);
@@ -96,7 +98,12 @@ class FlagDependencyExportsPlugin {
 
 						// Start with all modules without provided exports
 						for (const module of modules) {
-							if (!module.buildMeta.providedExports) {
+							if (module.buildInfo.temporaryProvidedExports) {
+								// Clear exports when they are temporary
+								// and recreate them
+								module.buildMeta.providedExports = null;
+								queue.enqueue(module);
+							} else if (!module.buildMeta.providedExports) {
 								queue.enqueue(module);
 							}
 						}
@@ -112,7 +119,9 @@ class FlagDependencyExportsPlugin {
 								)
 									? new Set(module.buildMeta.providedExports)
 									: new Set();
+								providedExportsAreTemporary = false;
 								processDependenciesBlock(module);
+								module.buildInfo.temporaryProvidedExports = providedExportsAreTemporary;
 								if (!moduleWithExports) {
 									module.buildMeta.providedExports = true;
 									notifyDependencies();

package/lib/NormalModule.js

@@ -184,6 +184,21 @@ class NormalModule extends Module {
 			resolve(context, request, callback) {
 				resolver.resolve({}, context, request, {}, callback);
 			},
+			getResolve(options) {
+				const child = options ? resolver.withOptions(options) : resolver;
+				return (context, request, callback) => {
+					if (callback) {
+						child.resolve({}, context, request, {}, callback);
+					} else {
+						return new Promise((resolve, reject) => {
+							child.resolve({}, context, request, {}, (err, result) => {
+								if (err) reject(err);
+								else resolve(result);
+							});
+						});
+					}
+				};
+			},
 			emitFile: (name, content, sourceMap) => {
 				if (!this.buildInfo.assets) {
 					this.buildInfo.assets = Object.create(null);

package/lib/ResolverFactory.js

@@ -7,6 +7,8 @@
 const { Tapable, HookMap, SyncHook, SyncWaterfallHook } = require("tapable");
 const Factory = require("enhanced-resolve").ResolverFactory;
 
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+
 module.exports = class ResolverFactory extends Tapable {
 	constructor() {
 		super();
@@ -53,11 +55,22 @@ module.exports = class ResolverFactory extends Tapable {
 	}
 
 	_create(type, resolveOptions) {
+		const originalResolveOptions = Object.assign({}, resolveOptions);
 		resolveOptions = this.hooks.resolveOptions.for(type).call(resolveOptions);
 		const resolver = Factory.createResolver(resolveOptions);
 		if (!resolver) {
 			throw new Error("No resolver created");
 		}
+		/** @type {Map<Object, Resolver>} */
+		const childCache = new Map();
+		resolver.withOptions = options => {
+			const cacheEntry = childCache.get(options);
+			if (cacheEntry !== undefined) return cacheEntry;
+			const mergedOptions = Object.assign({}, originalResolveOptions, options);
+			const resolver = this.get(type, mergedOptions);
+			childCache.set(options, resolver);
+			return resolver;
+		};
 		this.hooks.resolver.for(type).call(resolver, resolveOptions);
 		return resolver;
 	}

package/lib/WebpackOptionsDefaulter.js

@@ -302,10 +302,10 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		this.set("optimization.minimizer", "make", options => [
 			{
 				apply: compiler => {
-					// Lazy load the uglifyjs plugin
-					const UglifyJsPlugin = require("uglifyjs-webpack-plugin");
+					// Lazy load the Terser plugin
+					const TerserPlugin = require("terser-webpack-plugin");
 					const SourceMapDevToolPlugin = require("./SourceMapDevToolPlugin");
-					new UglifyJsPlugin({
+					new TerserPlugin({
 						cache: true,
 						parallel: true,
 						sourceMap:

package/lib/optimize/MinMaxSizeWarning.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("../WebpackError");
+const SizeFormatHelpers = require("../SizeFormatHelpers");
+
+class MinMaxSizeWarning extends WebpackError {
+	constructor(keys, minSize, maxSize) {
+		let keysMessage = "Fallback cache group";
+		if (keys) {
+			keysMessage =
+				keys.length > 1
+					? `Cache groups ${keys.sort().join(", ")}`
+					: `Cache group ${keys[0]}`;
+		}
+		super(
+			`SplitChunksPlugin\n` +
+				`${keysMessage}\n` +
+				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
+				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
+				"This seem to be a invalid optimiziation.splitChunks configuration."
+		);
+	}
+}
+
+module.exports = MinMaxSizeWarning;

package/lib/optimize/SplitChunksPlugin.js

@@ -9,6 +9,7 @@ const SortableSet = require("../util/SortableSet");
 const GraphHelpers = require("../GraphHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const deterministicGrouping = require("../util/deterministicGrouping");
+const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 const contextify = require("../util/identifier").contextify;
 
 /** @typedef {import("../Compiler")} Compiler */
@@ -96,6 +97,8 @@ const compareEntries = (a, b) => {
 	}
 };
 
+const compareNumbers = (a, b) => a - b;
+
 const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
 const ALL_CHUNK_FILTER = chunk => true;
@@ -340,7 +343,7 @@ module.exports = class SplitChunksPlugin {
 					}
 					const getKey = chunks => {
 						return Array.from(chunks, c => indexMap.get(c))
-							.sort()
+							.sort(compareNumbers)
 							.join();
 					};
 					/** @type {Map<string, Set<Chunk>>} */
@@ -436,6 +439,7 @@ module.exports = class SplitChunksPlugin {
 					 * @property {SortableSet} modules
 					 * @property {TODO} cacheGroup
 					 * @property {string} name
+					 * @property {boolean} validateSize
 					 * @property {number} size
 					 * @property {Set<Chunk>} chunks
 					 * @property {Set<Chunk>} reuseableChunks
@@ -473,8 +477,8 @@ module.exports = class SplitChunksPlugin {
 						// Elsewise we create the key from chunks and cache group key
 						// This automatically merges equal names
 						const key =
-							(name && `name:${name}`) ||
-							`chunks:${selectedChunksKey} key:${cacheGroup.key}`;
+							cacheGroup.key +
+							(name ? ` name:${name}` : ` chunks:${selectedChunksKey}`);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -484,21 +488,18 @@ module.exports = class SplitChunksPlugin {
 									modules: new SortableSet(undefined, sortByIdentifier),
 									cacheGroup,
 									name,
+									validateSize: cacheGroup.minSize > 0,
 									size: 0,
 									chunks: new Set(),
 									reuseableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
-						} else {
-							if (info.cacheGroup !== cacheGroup) {
-								if (info.cacheGroup.priority < cacheGroup.priority) {
-									info.cacheGroup = cacheGroup;
-								}
-							}
 						}
 						info.modules.add(module);
-						info.size += module.size();
+						if (info.validateSize) {
+							info.size += module.size();
+						}
 						if (!info.chunksKeys.has(selectedChunksKey)) {
 							info.chunksKeys.add(selectedChunksKey);
 							for (const chunk of selectedChunks) {
@@ -535,6 +536,10 @@ module.exports = class SplitChunksPlugin {
 										: cacheGroupSource.enforce
 											? 0
 											: this.options.minSize,
+								minSizeForMaxSize:
+									cacheGroupSource.minSize !== undefined
+										? cacheGroupSource.minSize
+										: this.options.minSize,
 								maxSize:
 									cacheGroupSource.maxSize !== undefined
 										? cacheGroupSource.maxSize
@@ -596,7 +601,15 @@ module.exports = class SplitChunksPlugin {
 						}
 					}
 
-					/** @type {Map<Chunk, {minSize: number, maxSize: number, automaticNameDelimiter: string}>} */
+					// Filter items were size < minSize
+					for (const pair of chunksInfoMap) {
+						const info = pair[1];
+						if (info.validateSize && info.size < info.cacheGroup.minSize) {
+							chunksInfoMap.delete(pair[0]);
+						}
+					}
+
+					/** @type {Map<Chunk, {minSize: number, maxSize: number, automaticNameDelimiter: string, keys: string[]}>} */
 					const maxSizeQueueMap = new Map();
 
 					while (chunksInfoMap.size > 0) {
@@ -606,20 +619,15 @@ module.exports = class SplitChunksPlugin {
 						for (const pair of chunksInfoMap) {
 							const key = pair[0];
 							const info = pair[1];
-							if (info.size >= info.cacheGroup.minSize) {
-								if (bestEntry === undefined) {
-									bestEntry = info;
-									bestEntryKey = key;
-								} else if (compareEntries(bestEntry, info) < 0) {
-									bestEntry = info;
-									bestEntryKey = key;
-								}
+							if (bestEntry === undefined) {
+								bestEntry = info;
+								bestEntryKey = key;
+							} else if (compareEntries(bestEntry, info) < 0) {
+								bestEntry = info;
+								bestEntryKey = key;
 							}
 						}
 
-						// No suitable item left
-						if (bestEntry === undefined) break;
-
 						const item = bestEntry;
 						chunksInfoMap.delete(bestEntryKey);
 
@@ -666,29 +674,38 @@ module.exports = class SplitChunksPlugin {
 						// Skip when no chunk selected
 						if (usedChunks.length === 0) continue;
 
-						const chunkInLimit = usedChunks.filter(chunk => {
-							// respect max requests when not enforced
-							const maxRequests = chunk.isOnlyInitial()
-								? item.cacheGroup.maxInitialRequests
-								: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
-							return !isFinite(maxRequests) || getRequests(chunk) < maxRequests;
-						});
-
-						if (chunkInLimit.length < usedChunks.length) {
-							for (const module of item.modules) {
-								addModuleToChunksInfoMap(
-									item.cacheGroup,
-									chunkInLimit,
-									getKey(chunkInLimit),
-									module
+						if (
+							Number.isFinite(item.cacheGroup.maxInitialRequests) ||
+							Number.isFinite(item.cacheGroup.maxAsyncRequests)
+						) {
+							const chunkInLimit = usedChunks.filter(chunk => {
+								// respect max requests when not enforced
+								const maxRequests = chunk.isOnlyInitial()
+									? item.cacheGroup.maxInitialRequests
+									: chunk.canBeInitial()
+										? Math.min(
+												item.cacheGroup.maxInitialRequests,
+												item.cacheGroup.maxAsyncRequests
+										  )
+										: item.cacheGroup.maxAsyncRequests;
+								return (
+									!isFinite(maxRequests) || getRequests(chunk) < maxRequests
 								);
+							});
+
+							if (chunkInLimit.length < usedChunks.length) {
+								if (chunkInLimit.length >= item.cacheGroup.minChunks) {
+									for (const module of item.modules) {
+										addModuleToChunksInfoMap(
+											item.cacheGroup,
+											chunkInLimit,
+											getKey(chunkInLimit),
+											module
+										);
+									}
+								}
+								continue;
 							}
-							continue;
 						}
 
 						// Create the new chunk if not reusing one
@@ -758,30 +775,45 @@ module.exports = class SplitChunksPlugin {
 							maxSizeQueueMap.set(newChunk, {
 								minSize: Math.max(
 									oldMaxSizeSettings ? oldMaxSizeSettings.minSize : 0,
-									item.cacheGroup.minSize
+									item.cacheGroup.minSizeForMaxSize
 								),
 								maxSize: Math.min(
 									oldMaxSizeSettings ? oldMaxSizeSettings.maxSize : Infinity,
 									item.cacheGroup.maxSize
 								),
-								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter
+								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
+								keys: oldMaxSizeSettings
+									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									: [item.cacheGroup.key]
 							});
 						}
 
 						// remove all modules from other entries and update size
 						for (const [key, info] of chunksInfoMap) {
 							if (isOverlap(info.chunks, item.chunks)) {
-								const oldSize = info.modules.size;
-								for (const module of item.modules) {
-									info.modules.delete(module);
-								}
-								if (info.modules.size === 0) {
-									chunksInfoMap.delete(key);
-									continue;
-								}
-								if (info.modules.size !== oldSize) {
-									info.size = getModulesSize(info.modules);
-									if (info.size < info.cacheGroup.minSize) {
+								if (info.validateSize) {
+									// update modules and total size
+									// may remove it from the map when < minSize
+									const oldSize = info.modules.size;
+									for (const module of item.modules) {
+										info.modules.delete(module);
+									}
+									if (info.modules.size === 0) {
+										chunksInfoMap.delete(key);
+										continue;
+									}
+									if (info.modules.size !== oldSize) {
+										info.size = getModulesSize(info.modules);
+										if (info.size < info.cacheGroup.minSize) {
+											chunksInfoMap.delete(key);
+										}
+									}
+								} else {
+									// only update the modules
+									for (const module of item.modules) {
+										info.modules.delete(module);
+									}
+									if (info.modules.size === 0) {
 										chunksInfoMap.delete(key);
 									}
 								}
@@ -789,13 +821,24 @@ module.exports = class SplitChunksPlugin {
 						}
 					}
 
+					const incorrectMinMaxSizeSet = new Set();
+
 					// Make sure that maxSize is fulfilled
 					for (const chunk of compilation.chunks.slice()) {
-						const { minSize, maxSize, automaticNameDelimiter } =
+						const { minSize, maxSize, automaticNameDelimiter, keys } =
 							maxSizeQueueMap.get(chunk) || this.options.fallbackCacheGroup;
 						if (!maxSize) continue;
+						if (minSize > maxSize) {
+							const warningKey = `${keys && keys.join()} ${minSize} ${maxSize}`;
+							if (!incorrectMinMaxSizeSet.has(warningKey)) {
+								incorrectMinMaxSizeSet.add(warningKey);
+								compilation.warnings.push(
+									new MinMaxSizeWarning(keys, minSize, maxSize)
+								);
+							}
+						}
 						const results = deterministicGroupingForModules({
-							maxSize,
+							maxSize: Math.max(minSize, maxSize),
 							minSize,
 							items: chunk.modulesIterable,
 							getKey(module) {

package/lib/util/deterministicGrouping.js

@@ -124,6 +124,13 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	/** @type {Node<T>[]} */
 	const initialNodes = [];
 
+	// lexically ordering of keys
+	nodes.sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+
 	// return nodes bigger than maxSize directly as group
 	for (const node of nodes) {
 		if (node.size >= maxSize) {
@@ -134,13 +141,6 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	}
 
 	if (initialNodes.length > 0) {
-		// lexically ordering of keys
-		initialNodes.sort((a, b) => {
-			if (a.key < b.key) return -1;
-			if (a.key > b.key) return 1;
-			return 0;
-		});
-
 		// calculate similarities between lexically adjacent nodes
 		/** @type {number[]} */
 		const similarities = [];
@@ -150,76 +150,99 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 			similarities.push(similarity(a.key, b.key));
 		}
 
-		const queue = [new Group(initialNodes, similarities)];
+		const initialGroup = new Group(initialNodes, similarities);
 
-		while (queue.length) {
-			const group = queue.pop();
-			// only groups bigger than maxSize need to be splitted
-			if (group.size < maxSize) {
-				result.push(group);
-				continue;
+		if (initialGroup.size < minSize) {
+			// We hit an edgecase where the working set is already smaller than minSize
+			// We merge it with the smallest result node to keep minSize intact
+			if (result.length > 0) {
+				const smallestGroup = result.reduce(
+					(min, group) => (min.size > group.size ? group : min)
+				);
+				for (const node of initialGroup.nodes) smallestGroup.nodes.push(node);
+				smallestGroup.nodes.sort((a, b) => {
+					if (a.key < b.key) return -1;
+					if (a.key > b.key) return 1;
+					return 0;
+				});
+			} else {
+				// There are no other nodes
+				// We use all nodes and have to accept that it's smaller than minSize
+				result.push(initialGroup);
 			}
+		} else {
+			const queue = [initialGroup];
 
-			// find unsplittable area from left and right
-			// going minSize from left and right
-			let left = 0;
-			let leftSize = 0;
-			while (leftSize < minSize) {
-				leftSize += group.nodes[left].size;
-				left++;
-			}
-			let right = group.nodes.length - 1;
-			let rightSize = 0;
-			while (rightSize < minSize) {
-				rightSize += group.nodes[right].size;
-				right--;
-			}
+			while (queue.length) {
+				const group = queue.pop();
+				// only groups bigger than maxSize need to be splitted
+				if (group.size < maxSize) {
+					result.push(group);
+					continue;
+				}
 
-			if (left - 1 > right) {
-				// can't split group while holding minSize
-				// because minSize is preferred of maxSize we return
-				// the group here even while it's too big
-				// To avoid this make sure maxSize > minSize * 3
-				result.push(group);
-				continue;
-			}
-			if (left <= right) {
-				// when there is a area between left and right
-				// we look for best split point
-				// we split at the minimum similarity
-				// here key space is separated the most
-				let best = left - 1;
-				let bestSimilarity = group.similarities[best];
-				for (let i = left; i <= right; i++) {
-					const similarity = group.similarities[i];
-					if (similarity < bestSimilarity) {
-						best = i;
-						bestSimilarity = similarity;
+				// find unsplittable area from left and right
+				// going minSize from left and right
+				// at least one node need to be included otherwise we get stuck
+				let left = 0;
+				let leftSize = 0;
+				while (leftSize <= minSize) {
+					leftSize += group.nodes[left].size;
+					left++;
+				}
+				let right = group.nodes.length - 1;
+				let rightSize = 0;
+				while (rightSize <= minSize) {
+					rightSize += group.nodes[right].size;
+					right--;
+				}
+
+				if (left - 1 > right) {
+					// can't split group while holding minSize
+					// because minSize is preferred of maxSize we return
+					// the group here even while it's too big
+					// To avoid this make sure maxSize > minSize * 3
+					result.push(group);
+					continue;
+				}
+				if (left <= right) {
+					// when there is a area between left and right
+					// we look for best split point
+					// we split at the minimum similarity
+					// here key space is separated the most
+					let best = left - 1;
+					let bestSimilarity = group.similarities[best];
+					for (let i = left; i <= right; i++) {
+						const similarity = group.similarities[i];
+						if (similarity < bestSimilarity) {
+							best = i;
+							bestSimilarity = similarity;
+						}
 					}
+					left = best + 1;
+					right = best;
 				}
-				left = best + 1;
-				right = best;
-			}
 
-			// create two new groups for left and right area
-			// and queue them up
-			const rightNodes = [group.nodes[right + 1]];
-			/** @type {number[]} */
-			const rightSimilaries = [];
-			for (let i = right + 2; i < group.nodes.length; i++) {
-				rightSimilaries.push(group.similarities[i - 1]);
-				rightNodes.push(group.nodes[i]);
-			}
-			queue.push(new Group(rightNodes, rightSimilaries));
-
-			const leftNodes = [group.nodes[0]];
-			/** @type {number[]} */
-			const leftSimilaries = [];
-			for (let i = 1; i < left; i++) {
-				leftSimilaries.push(group.similarities[i - 1]);
-				leftNodes.push(group.nodes[i]);
+				// create two new groups for left and right area
+				// and queue them up
+				const rightNodes = [group.nodes[right + 1]];
+				/** @type {number[]} */
+				const rightSimilaries = [];
+				for (let i = right + 2; i < group.nodes.length; i++) {
+					rightSimilaries.push(group.similarities[i - 1]);
+					rightNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(rightNodes, rightSimilaries));
+
+				const leftNodes = [group.nodes[0]];
+				/** @type {number[]} */
+				const leftSimilaries = [];
+				for (let i = 1; i < left; i++) {
+					leftSimilaries.push(group.similarities[i - 1]);
+					leftNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(leftNodes, leftSimilaries));
 			}
-			queue.push(new Group(leftNodes, leftSimilaries));
 		}
 	}
 

package/lib/webpack.js

@@ -42,7 +42,7 @@ const webpack = (options, callback) => {
 		if (options.plugins && Array.isArray(options.plugins)) {
 			for (const plugin of options.plugins) {
 				if (typeof plugin === "function") {
-					plugin.apply(compiler);
+					plugin.call(compiler, compiler);
 				} else {
 					plugin.apply(compiler);
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "4.25.1",
+  "version": "4.27.1",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "node-libs-browser": "^2.0.0",
     "schema-utils": "^0.4.4",
     "tapable": "^1.1.0",
-    "uglifyjs-webpack-plugin": "^1.2.4",
+    "terser-webpack-plugin": "^1.1.0",
     "watchpack": "^1.5.0",
     "webpack-sources": "^1.3.0"
   },

package/schemas/WebpackOptions.json

@@ -1879,7 +1879,7 @@
     "WebpackPluginFunction": {
       "description": "Function acting as plugin",
       "instanceof": "Function",
-      "tsType": "(compiler: import('../lib/Compiler')) => void"
+      "tsType": "(this: import('../lib/Compiler'), compiler: import('../lib/Compiler')) => void"
     },
     "WebpackPluginInstance": {
       "description": "Plugin instance",