remove node_modules

13 files changed, 0 insertions, 3114 deletions

diff --git a/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js b/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js
deleted file mode 100644
index e3a4c37ee..000000000
--- a/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class AggressiveMergingPlugin {
-	constructor(options) {
-		if (
-			(options !== undefined && typeof options !== "object") ||
-			Array.isArray(options)
-		) {
-			throw new Error(
-				"Argument should be an options object. To use defaults, pass in nothing.\nFor more info on options, see https://webpack.js.org/plugins/"
-			);
-		}
-		this.options = options || {};
-	}
-
-	apply(compiler) {
-		const options = this.options;
-		const minSizeReduce = options.minSizeReduce || 1.5;
-
-		compiler.hooks.thisCompilation.tap(
-			"AggressiveMergingPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunksAdvanced.tap(
-					"AggressiveMergingPlugin",
-					chunks => {
-						let combinations = [];
-						chunks.forEach((a, idx) => {
-							if (a.canBeInitial()) return;
-							for (let i = 0; i < idx; i++) {
-								const b = chunks[i];
-								if (b.canBeInitial()) continue;
-								combinations.push({
-									a,
-									b,
-									improvement: undefined
-								});
-							}
-						});
-
-						for (const pair of combinations) {
-							const a = pair.b.size({
-								chunkOverhead: 0
-							});
-							const b = pair.a.size({
-								chunkOverhead: 0
-							});
-							const ab = pair.b.integratedSize(pair.a, {
-								chunkOverhead: 0
-							});
-							let newSize;
-							if (ab === false) {
-								pair.improvement = false;
-								return;
-							} else {
-								newSize = ab;
-							}
-
-							pair.improvement = (a + b) / newSize;
-						}
-						combinations = combinations.filter(pair => {
-							return pair.improvement !== false;
-						});
-						combinations.sort((a, b) => {
-							return b.improvement - a.improvement;
-						});
-
-						const pair = combinations[0];
-
-						if (!pair) return;
-						if (pair.improvement < minSizeReduce) return;
-
-						if (pair.b.integrate(pair.a, "aggressive-merge")) {
-							chunks.splice(chunks.indexOf(pair.a), 1);
-							return true;
-						}
-					}
-				);
-			}
-		);
-	}
-}
-
-module.exports = AggressiveMergingPlugin;
diff --git a/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js b/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js
deleted file mode 100644
index 9aec3644b..000000000
--- a/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const identifierUtils = require("../util/identifier");
-const { intersect } = require("../util/SetHelpers");
-const validateOptions = require("schema-utils");
-const schema = require("../../schemas/plugins/optimize/AggressiveSplittingPlugin.json");
-
-const moveModuleBetween = (oldChunk, newChunk) => {
-	return module => {
-		oldChunk.moveModule(module, newChunk);
-	};
-};
-
-const isNotAEntryModule = entryModule => {
-	return module => {
-		return entryModule !== module;
-	};
-};
-
-class AggressiveSplittingPlugin {
-	constructor(options) {
-		validateOptions(schema, options || {}, "Aggressive Splitting Plugin");
-
-		this.options = options || {};
-		if (typeof this.options.minSize !== "number") {
-			this.options.minSize = 30 * 1024;
-		}
-		if (typeof this.options.maxSize !== "number") {
-			this.options.maxSize = 50 * 1024;
-		}
-		if (typeof this.options.chunkOverhead !== "number") {
-			this.options.chunkOverhead = 0;
-		}
-		if (typeof this.options.entryChunkMultiplicator !== "number") {
-			this.options.entryChunkMultiplicator = 1;
-		}
-	}
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"AggressiveSplittingPlugin",
-			compilation => {
-				let needAdditionalSeal = false;
-				let newSplits;
-				let fromAggressiveSplittingSet;
-				let chunkSplitDataMap;
-				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
-					newSplits = [];
-					fromAggressiveSplittingSet = new Set();
-					chunkSplitDataMap = new Map();
-				});
-				compilation.hooks.optimizeChunksAdvanced.tap(
-					"AggressiveSplittingPlugin",
-					chunks => {
-						// Precompute stuff
-						const nameToModuleMap = new Map();
-						const moduleToNameMap = new Map();
-						for (const m of compilation.modules) {
-							const name = identifierUtils.makePathsRelative(
-								compiler.context,
-								m.identifier(),
-								compilation.cache
-							);
-							nameToModuleMap.set(name, m);
-							moduleToNameMap.set(m, name);
-						}
-
-						// Check used chunk ids
-						const usedIds = new Set();
-						for (const chunk of chunks) {
-							usedIds.add(chunk.id);
-						}
-
-						const recordedSplits =
-							(compilation.records && compilation.records.aggressiveSplits) ||
-							[];
-						const usedSplits = newSplits
-							? recordedSplits.concat(newSplits)
-							: recordedSplits;
-
-						const minSize = this.options.minSize;
-						const maxSize = this.options.maxSize;
-
-						const applySplit = splitData => {
-							// Cannot split if id is already taken
-							if (splitData.id !== undefined && usedIds.has(splitData.id)) {
-								return false;
-							}
-
-							// Get module objects from names
-							const selectedModules = splitData.modules.map(name =>
-								nameToModuleMap.get(name)
-							);
-
-							// Does the modules exist at all?
-							if (!selectedModules.every(Boolean)) return false;
-
-							// Check if size matches (faster than waiting for hash)
-							const size = selectedModules.reduce(
-								(sum, m) => sum + m.size(),
-								0
-							);
-							if (size !== splitData.size) return false;
-
-							// get chunks with all modules
-							const selectedChunks = intersect(
-								selectedModules.map(m => new Set(m.chunksIterable))
-							);
-
-							// No relevant chunks found
-							if (selectedChunks.size === 0) return false;
-
-							// The found chunk is already the split or similar
-							if (
-								selectedChunks.size === 1 &&
-								Array.from(selectedChunks)[0].getNumberOfModules() ===
-									selectedModules.length
-							) {
-								const chunk = Array.from(selectedChunks)[0];
-								if (fromAggressiveSplittingSet.has(chunk)) return false;
-								fromAggressiveSplittingSet.add(chunk);
-								chunkSplitDataMap.set(chunk, splitData);
-								return true;
-							}
-
-							// split the chunk into two parts
-							const newChunk = compilation.addChunk();
-							newChunk.chunkReason = "aggressive splitted";
-							for (const chunk of selectedChunks) {
-								selectedModules.forEach(moveModuleBetween(chunk, newChunk));
-								chunk.split(newChunk);
-								chunk.name = null;
-							}
-							fromAggressiveSplittingSet.add(newChunk);
-							chunkSplitDataMap.set(newChunk, splitData);
-
-							if (splitData.id !== null && splitData.id !== undefined) {
-								newChunk.id = splitData.id;
-							}
-							return true;
-						};
-
-						// try to restore to recorded splitting
-						let changed = false;
-						for (let j = 0; j < usedSplits.length; j++) {
-							const splitData = usedSplits[j];
-							if (applySplit(splitData)) changed = true;
-						}
-
-						// for any chunk which isn't splitted yet, split it and create a new entry
-						// start with the biggest chunk
-						const sortedChunks = chunks.slice().sort((a, b) => {
-							const diff1 = b.modulesSize() - a.modulesSize();
-							if (diff1) return diff1;
-							const diff2 = a.getNumberOfModules() - b.getNumberOfModules();
-							if (diff2) return diff2;
-							const modulesA = Array.from(a.modulesIterable);
-							const modulesB = Array.from(b.modulesIterable);
-							modulesA.sort();
-							modulesB.sort();
-							const aI = modulesA[Symbol.iterator]();
-							const bI = modulesB[Symbol.iterator]();
-							// eslint-disable-next-line no-constant-condition
-							while (true) {
-								const aItem = aI.next();
-								const bItem = bI.next();
-								if (aItem.done) return 0;
-								const aModuleIdentifier = aItem.value.identifier();
-								const bModuleIdentifier = bItem.value.identifier();
-								if (aModuleIdentifier > bModuleIdentifier) return -1;
-								if (aModuleIdentifier < bModuleIdentifier) return 1;
-							}
-						});
-						for (const chunk of sortedChunks) {
-							if (fromAggressiveSplittingSet.has(chunk)) continue;
-							const size = chunk.modulesSize();
-							if (size > maxSize && chunk.getNumberOfModules() > 1) {
-								const modules = chunk
-									.getModules()
-									.filter(isNotAEntryModule(chunk.entryModule))
-									.sort((a, b) => {
-										a = a.identifier();
-										b = b.identifier();
-										if (a > b) return 1;
-										if (a < b) return -1;
-										return 0;
-									});
-								const selectedModules = [];
-								let selectedModulesSize = 0;
-								for (let k = 0; k < modules.length; k++) {
-									const module = modules[k];
-									const newSize = selectedModulesSize + module.size();
-									if (newSize > maxSize && selectedModulesSize >= minSize) {
-										break;
-									}
-									selectedModulesSize = newSize;
-									selectedModules.push(module);
-								}
-								if (selectedModules.length === 0) continue;
-								const splitData = {
-									modules: selectedModules
-										.map(m => moduleToNameMap.get(m))
-										.sort(),
-									size: selectedModulesSize
-								};
-
-								if (applySplit(splitData)) {
-									newSplits = (newSplits || []).concat(splitData);
-									changed = true;
-								}
-							}
-						}
-						if (changed) return true;
-					}
-				);
-				compilation.hooks.recordHash.tap(
-					"AggressiveSplittingPlugin",
-					records => {
-						// 4. save made splittings to records
-						const allSplits = new Set();
-						const invalidSplits = new Set();
-
-						// Check if some splittings are invalid
-						// We remove invalid splittings and try again
-						for (const chunk of compilation.chunks) {
-							const splitData = chunkSplitDataMap.get(chunk);
-							if (splitData !== undefined) {
-								if (splitData.hash && chunk.hash !== splitData.hash) {
-									// Split was successful, but hash doesn't equal
-									// We can throw away the split since it's useless now
-									invalidSplits.add(splitData);
-								}
-							}
-						}
-
-						if (invalidSplits.size > 0) {
-							records.aggressiveSplits = records.aggressiveSplits.filter(
-								splitData => !invalidSplits.has(splitData)
-							);
-							needAdditionalSeal = true;
-						} else {
-							// set hash and id values on all (new) splittings
-							for (const chunk of compilation.chunks) {
-								const splitData = chunkSplitDataMap.get(chunk);
-								if (splitData !== undefined) {
-									splitData.hash = chunk.hash;
-									splitData.id = chunk.id;
-									allSplits.add(splitData);
-									// set flag for stats
-									chunk.recorded = true;
-								}
-							}
-
-							// Also add all unused historial splits (after the used ones)
-							// They can still be used in some future compilation
-							const recordedSplits =
-								compilation.records && compilation.records.aggressiveSplits;
-							if (recordedSplits) {
-								for (const splitData of recordedSplits) {
-									if (!invalidSplits.has(splitData)) allSplits.add(splitData);
-								}
-							}
-
-							// record all splits
-							records.aggressiveSplits = Array.from(allSplits);
-
-							needAdditionalSeal = false;
-						}
-					}
-				);
-				compilation.hooks.needAdditionalSeal.tap(
-					"AggressiveSplittingPlugin",
-					() => {
-						if (needAdditionalSeal) {
-							needAdditionalSeal = false;
-							return true;
-						}
-					}
-				);
-			}
-		);
-	}
-}
-module.exports = AggressiveSplittingPlugin;
diff --git a/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js b/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js
deleted file mode 100644
index f507e426c..000000000
--- a/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const sortByIndex = (a, b) => {
-	return a.index - b.index;
-};
-
-const sortByIndex2 = (a, b) => {
-	return a.index2 - b.index2;
-};
-
-class ChunkModuleIdRangePlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
-			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
-				const chunk = compilation.chunks.find(
-					chunk => chunk.name === options.name
-				);
-				if (!chunk) {
-					throw new Error(
-						`ChunkModuleIdRangePlugin: Chunk with name '${
-							options.name
-						}"' was not found`
-					);
-				}
-
-				let chunkModules;
-				if (options.order) {
-					chunkModules = Array.from(chunk.modulesIterable);
-					switch (options.order) {
-						case "index":
-							chunkModules.sort(sortByIndex);
-							break;
-						case "index2":
-							chunkModules.sort(sortByIndex2);
-							break;
-						default:
-							throw new Error(
-								"ChunkModuleIdRangePlugin: unexpected value of order"
-							);
-					}
-				} else {
-					chunkModules = modules.filter(m => {
-						return m.chunksIterable.has(chunk);
-					});
-				}
-
-				let currentId = options.start || 0;
-				for (let i = 0; i < chunkModules.length; i++) {
-					const m = chunkModules[i];
-					if (m.id === null) {
-						m.id = currentId++;
-					}
-					if (options.end && currentId > options.end) break;
-				}
-			});
-		});
-	}
-}
-module.exports = ChunkModuleIdRangePlugin;
diff --git a/node_modules/webpack/lib/optimize/ConcatenatedModule.js b/node_modules/webpack/lib/optimize/ConcatenatedModule.js
deleted file mode 100644
index 52d33e6f3..000000000
--- a/node_modules/webpack/lib/optimize/ConcatenatedModule.js
+++ /dev/null
@@ -1,1495 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Module = require("../Module");
-const Template = require("../Template");
-const Parser = require("../Parser");
-const eslintScope = require("eslint-scope");
-const { ConcatSource, ReplaceSource } = require("webpack-sources");
-const DependencyReference = require("../dependencies/DependencyReference");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
-const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
-const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
-const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
-const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
-const createHash = require("../util/createHash");
-
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../util/createHash").Hash} Hash */
-
-/**
- * @typedef {Object} ConcatenationEntry
- * @property {"concatenated" | "external"} type
- * @property {Module} module
- */
-
-const ensureNsObjSource = (
-	info,
-	moduleToInfoMap,
-	requestShortener,
-	strictHarmonyModule
-) => {
-	if (!info.hasNamespaceObject) {
-		info.hasNamespaceObject = true;
-		const name = info.exportMap.get(true);
-		const nsObj = [`var ${name} = {};`, `__webpack_require__.r(${name});`];
-		for (const exportName of info.module.buildMeta.providedExports) {
-			const finalName = getFinalName(
-				info,
-				exportName,
-				moduleToInfoMap,
-				requestShortener,
-				false,
-				strictHarmonyModule
-			);
-			nsObj.push(
-				`__webpack_require__.d(${name}, ${JSON.stringify(
-					exportName
-				)}, function() { return ${finalName}; });`
-			);
-		}
-		info.namespaceObjectSource = nsObj.join("\n") + "\n";
-	}
-};
-
-const getExternalImport = (
-	importedModule,
-	info,
-	exportName,
-	asCall,
-	strictHarmonyModule
-) => {
-	const used = importedModule.isUsed(exportName);
-	if (!used) return "/* unused reexport */undefined";
-	const comment =
-		used !== exportName ? ` ${Template.toNormalComment(exportName)}` : "";
-	switch (importedModule.buildMeta.exportsType) {
-		case "named":
-			if (exportName === "default") {
-				return info.name;
-			} else if (exportName === true) {
-				info.interopNamespaceObjectUsed = true;
-				return info.interopNamespaceObjectName;
-			} else {
-				break;
-			}
-		case "namespace":
-			if (exportName === true) {
-				return info.name;
-			} else {
-				break;
-			}
-		default:
-			if (strictHarmonyModule) {
-				if (exportName === "default") {
-					return info.name;
-				} else if (exportName === true) {
-					info.interopNamespaceObjectUsed = true;
-					return info.interopNamespaceObjectName;
-				} else {
-					return "/* non-default import from non-esm module */undefined";
-				}
-			} else {
-				if (exportName === "default") {
-					info.interopDefaultAccessUsed = true;
-					return asCall
-						? `${info.interopDefaultAccessName}()`
-						: `${info.interopDefaultAccessName}.a`;
-				} else if (exportName === true) {
-					return info.name;
-				} else {
-					break;
-				}
-			}
-	}
-	const reference = `${info.name}[${JSON.stringify(used)}${comment}]`;
-	if (asCall) return `Object(${reference})`;
-	return reference;
-};
-
-const getFinalName = (
-	info,
-	exportName,
-	moduleToInfoMap,
-	requestShortener,
-	asCall,
-	strictHarmonyModule,
-	alreadyVisited = new Set()
-) => {
-	switch (info.type) {
-		case "concatenated": {
-			const directExport = info.exportMap.get(exportName);
-			if (directExport) {
-				if (exportName === true) {
-					ensureNsObjSource(
-						info,
-						moduleToInfoMap,
-						requestShortener,
-						strictHarmonyModule
-					);
-				} else if (!info.module.isUsed(exportName)) {
-					return "/* unused export */ undefined";
-				}
-				if (info.globalExports.has(directExport)) {
-					return directExport;
-				}
-				const name = info.internalNames.get(directExport);
-				if (!name) {
-					throw new Error(
-						`The export "${directExport}" in "${info.module.readableIdentifier(
-							requestShortener
-						)}" has no internal name`
-					);
-				}
-				return name;
-			}
-			const reexport = info.reexportMap.get(exportName);
-			if (reexport) {
-				if (alreadyVisited.has(reexport)) {
-					throw new Error(
-						`Circular reexports ${Array.from(
-							alreadyVisited,
-							e =>
-								`"${e.module.readableIdentifier(requestShortener)}".${
-									e.exportName
-								}`
-						).join(
-							" --> "
-						)} -(circular)-> "${reexport.module.readableIdentifier(
-							requestShortener
-						)}".${reexport.exportName}`
-					);
-				}
-				alreadyVisited.add(reexport);
-				const refInfo = moduleToInfoMap.get(reexport.module);
-				if (refInfo) {
-					// module is in the concatenation
-					return getFinalName(
-						refInfo,
-						reexport.exportName,
-						moduleToInfoMap,
-						requestShortener,
-						asCall,
-						strictHarmonyModule,
-						alreadyVisited
-					);
-				}
-			}
-			const problem =
-				`Cannot get final name for export "${exportName}" in "${info.module.readableIdentifier(
-					requestShortener
-				)}"` +
-				` (known exports: ${Array.from(info.exportMap.keys())
-					.filter(name => name !== true)
-					.join(" ")}, ` +
-				`known reexports: ${Array.from(info.reexportMap.keys()).join(" ")})`;
-			return `${Template.toNormalComment(problem)} undefined`;
-		}
-		case "external": {
-			const importedModule = info.module;
-			return getExternalImport(
-				importedModule,
-				info,
-				exportName,
-				asCall,
-				strictHarmonyModule
-			);
-		}
-	}
-};
-
-const addScopeSymbols1 = (s, nameSet, scopeSet) => {
-	let scope = s;
-	while (scope) {
-		if (scopeSet.has(scope)) break;
-		scopeSet.add(scope);
-		for (const variable of scope.variables) {
-			nameSet.add(variable.name);
-		}
-		scope = scope.upper;
-	}
-};
-
-const addScopeSymbols2 = (s, nameSet, scopeSet1, scopeSet2) => {
-	let scope = s;
-	while (scope) {
-		if (scopeSet1.has(scope)) break;
-		if (scopeSet2.has(scope)) break;
-		scopeSet1.add(scope);
-		for (const variable of scope.variables) {
-			nameSet.add(variable.name);
-		}
-		scope = scope.upper;
-	}
-};
-
-const getAllReferences = variable => {
-	let set = variable.references;
-	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	const identifiers = new Set(variable.identifiers);
-	for (const scope of variable.scope.childScopes) {
-		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some(id => identifiers.has(id))) {
-				set = set.concat(innerVar.references);
-				break;
-			}
-		}
-	}
-	return set;
-};
-
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
-
-	const nr = node.range;
-
-	const enterNode = n => {
-		if (!n) return undefined;
-		const r = n.range;
-		if (r) {
-			if (r[0] <= nr[0] && r[1] >= nr[1]) {
-				const path = getPathInAst(n, node);
-				if (path) {
-					path.push(n);
-					return path;
-				}
-			}
-		}
-		return undefined;
-	};
-
-	var i;
-	if (Array.isArray(ast)) {
-		for (i = 0; i < ast.length; i++) {
-			const enterResult = enterNode(ast[i]);
-			if (enterResult !== undefined) return enterResult;
-		}
-	} else if (ast && typeof ast === "object") {
-		const keys = Object.keys(ast);
-		for (i = 0; i < keys.length; i++) {
-			const value = ast[keys[i]];
-			if (Array.isArray(value)) {
-				const pathResult = getPathInAst(value, node);
-				if (pathResult !== undefined) return pathResult;
-			} else if (value && typeof value === "object") {
-				const enterResult = enterNode(value);
-				if (enterResult !== undefined) return enterResult;
-			}
-		}
-	}
-};
-
-class ConcatenatedModule extends Module {
-	constructor(rootModule, modules, concatenationList) {
-		super("javascript/esm", null);
-		super.setChunks(rootModule._chunks);
-
-		// Info from Factory
-		this.rootModule = rootModule;
-		this.factoryMeta = rootModule.factoryMeta;
-
-		// Info from Compilation
-		this.index = rootModule.index;
-		this.index2 = rootModule.index2;
-		this.depth = rootModule.depth;
-
-		// Info from Optimization
-		this.used = rootModule.used;
-		this.usedExports = rootModule.usedExports;
-
-		// Info from Build
-		this.buildInfo = {
-			strict: true,
-			cacheable: modules.every(m => m.buildInfo.cacheable),
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
-			fileDependencies: new Set(),
-			contextDependencies: new Set(),
-			assets: undefined
-		};
-		this.built = modules.some(m => m.built);
-		this.buildMeta = rootModule.buildMeta;
-
-		// Caching
-		this._numberOfConcatenatedModules = modules.length;
-
-		// Graph
-		const modulesSet = new Set(modules);
-		this.reasons = rootModule.reasons.filter(
-			reason =>
-				!(reason.dependency instanceof HarmonyImportDependency) ||
-				!modulesSet.has(reason.module)
-		);
-
-		this.dependencies = [];
-
-		this.warnings = [];
-		this.errors = [];
-		this._orderedConcatenationList =
-			concatenationList ||
-			ConcatenatedModule.createConcatenationList(rootModule, modulesSet, null);
-		for (const info of this._orderedConcatenationList) {
-			if (info.type === "concatenated") {
-				const m = info.module;
-
-				// populate dependencies
-				for (const d of m.dependencies.filter(
-					dep =>
-						!(dep instanceof HarmonyImportDependency) ||
-						!modulesSet.has(dep._module)
-				)) {
-					this.dependencies.push(d);
-				}
-				// populate file dependencies
-				if (m.buildInfo.fileDependencies) {
-					for (const file of m.buildInfo.fileDependencies) {
-						this.buildInfo.fileDependencies.add(file);
-					}
-				}
-				// populate context dependencies
-				if (m.buildInfo.contextDependencies) {
-					for (const context of m.buildInfo.contextDependencies) {
-						this.buildInfo.contextDependencies.add(context);
-					}
-				}
-				// populate warnings
-				for (const warning of m.warnings) {
-					this.warnings.push(warning);
-				}
-				// populate errors
-				for (const error of m.errors) {
-					this.errors.push(error);
-				}
-
-				if (m.buildInfo.assets) {
-					if (this.buildInfo.assets === undefined) {
-						this.buildInfo.assets = Object.create(null);
-					}
-					Object.assign(this.buildInfo.assets, m.buildInfo.assets);
-				}
-			}
-		}
-		this._identifier = this._createIdentifier();
-	}
-
-	get modules() {
-		return this._orderedConcatenationList
-			.filter(info => info.type === "concatenated")
-			.map(info => info.module);
-	}
-
-	identifier() {
-		return this._identifier;
-	}
-
-	readableIdentifier(requestShortener) {
-		return (
-			this.rootModule.readableIdentifier(requestShortener) +
-			` + ${this._numberOfConcatenatedModules - 1} modules`
-		);
-	}
-
-	libIdent(options) {
-		return this.rootModule.libIdent(options);
-	}
-
-	nameForCondition() {
-		return this.rootModule.nameForCondition();
-	}
-
-	build(options, compilation, resolver, fs, callback) {
-		throw new Error("Cannot build this module. It should be already built.");
-	}
-
-	size() {
-		// Guess size from embedded modules
-		return this._orderedConcatenationList.reduce((sum, info) => {
-			switch (info.type) {
-				case "concatenated":
-					return sum + info.module.size();
-				case "external":
-					return sum + 5;
-			}
-			return sum;
-		}, 0);
-	}
-
-	/**
-	 * @param {Module} rootModule the root of the concatenation
-	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
-	 * @param {Compilation} compilation the compilation context
-	 * @returns {ConcatenationEntry[]} concatenation list
-	 */
-	static createConcatenationList(rootModule, modulesSet, compilation) {
-		const list = [];
-		const set = new Set();
-
-		/**
-		 * @param {Module} module a module
-		 * @returns {(function(): Module)[]} imported modules in order
-		 */
-		const getConcatenatedImports = module => {
-			/** @type {WeakMap<DependencyReference, Dependency>} */
-			const map = new WeakMap();
-			const references = module.dependencies
-				.filter(dep => dep instanceof HarmonyImportDependency)
-				.map(dep => {
-					const ref = compilation.getDependencyReference(module, dep);
-					if (ref) map.set(ref, dep);
-					return ref;
-				})
-				.filter(ref => ref);
-			DependencyReference.sort(references);
-			// TODO webpack 5: remove this hack, see also DependencyReference
-			return references.map(ref => {
-				const dep = map.get(ref);
-				return () => compilation.getDependencyReference(module, dep).module;
-			});
-		};
-
-		const enterModule = getModule => {
-			const module = getModule();
-			if (!module) return;
-			if (set.has(module)) return;
-			set.add(module);
-			if (modulesSet.has(module)) {
-				const imports = getConcatenatedImports(module);
-				imports.forEach(enterModule);
-				list.push({
-					type: "concatenated",
-					module
-				});
-			} else {
-				list.push({
-					type: "external",
-					get module() {
-						// We need to use a getter here, because the module in the dependency
-						// could be replaced by some other process (i. e. also replaced with a
-						// concatenated module)
-						return getModule();
-					}
-				});
-			}
-		};
-
-		enterModule(() => rootModule);
-
-		return list;
-	}
-
-	_createIdentifier() {
-		let orderedConcatenationListIdentifiers = "";
-		for (let i = 0; i < this._orderedConcatenationList.length; i++) {
-			if (this._orderedConcatenationList[i].type === "concatenated") {
-				orderedConcatenationListIdentifiers += this._orderedConcatenationList[
-					i
-				].module.identifier();
-				orderedConcatenationListIdentifiers += " ";
-			}
-		}
-		const hash = createHash("md4");
-		hash.update(orderedConcatenationListIdentifiers);
-		return this.rootModule.identifier() + " " + hash.digest("hex");
-	}
-
-	source(dependencyTemplates, runtimeTemplate) {
-		const requestShortener = runtimeTemplate.requestShortener;
-		// Metainfo for each module
-		const modulesWithInfo = this._orderedConcatenationList.map((info, idx) => {
-			switch (info.type) {
-				case "concatenated": {
-					const exportMap = new Map();
-					const reexportMap = new Map();
-					for (const dep of info.module.dependencies) {
-						if (dep instanceof HarmonyExportSpecifierDependency) {
-							if (!exportMap.has(dep.name)) {
-								exportMap.set(dep.name, dep.id);
-							}
-						} else if (dep instanceof HarmonyExportExpressionDependency) {
-							if (!exportMap.has("default")) {
-								exportMap.set("default", "__WEBPACK_MODULE_DEFAULT_EXPORT__");
-							}
-						} else if (
-							dep instanceof HarmonyExportImportedSpecifierDependency
-						) {
-							const exportName = dep.name;
-							const importName = dep.id;
-							const importedModule = dep._module;
-							if (exportName && importName) {
-								if (!reexportMap.has(exportName)) {
-									reexportMap.set(exportName, {
-										module: importedModule,
-										exportName: importName,
-										dependency: dep
-									});
-								}
-							} else if (exportName) {
-								if (!reexportMap.has(exportName)) {
-									reexportMap.set(exportName, {
-										module: importedModule,
-										exportName: true,
-										dependency: dep
-									});
-								}
-							} else if (importedModule) {
-								for (const name of importedModule.buildMeta.providedExports) {
-									if (dep.activeExports.has(name) || name === "default") {
-										continue;
-									}
-									if (!reexportMap.has(name)) {
-										reexportMap.set(name, {
-											module: importedModule,
-											exportName: name,
-											dependency: dep
-										});
-									}
-								}
-							}
-						}
-					}
-					return {
-						type: "concatenated",
-						module: info.module,
-						index: idx,
-						ast: undefined,
-						internalSource: undefined,
-						source: undefined,
-						globalScope: undefined,
-						moduleScope: undefined,
-						internalNames: new Map(),
-						globalExports: new Set(),
-						exportMap: exportMap,
-						reexportMap: reexportMap,
-						hasNamespaceObject: false,
-						namespaceObjectSource: null
-					};
-				}
-				case "external":
-					return {
-						type: "external",
-						module: info.module,
-						index: idx,
-						name: undefined,
-						interopNamespaceObjectUsed: false,
-						interopNamespaceObjectName: undefined,
-						interopDefaultAccessUsed: false,
-						interopDefaultAccessName: undefined
-					};
-				default:
-					throw new Error(`Unsupported concatenation entry type ${info.type}`);
-			}
-		});
-
-		// Create mapping from module to info
-		const moduleToInfoMap = new Map();
-		for (const m of modulesWithInfo) {
-			moduleToInfoMap.set(m.module, m);
-		}
-
-		// Configure template decorators for dependencies
-		const innerDependencyTemplates = new Map(dependencyTemplates);
-
-		innerDependencyTemplates.set(
-			HarmonyImportSpecifierDependency,
-			new HarmonyImportSpecifierDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyImportSpecifierDependency),
-				moduleToInfoMap
-			)
-		);
-		innerDependencyTemplates.set(
-			HarmonyImportSideEffectDependency,
-			new HarmonyImportSideEffectDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyImportSideEffectDependency),
-				moduleToInfoMap
-			)
-		);
-		innerDependencyTemplates.set(
-			HarmonyExportSpecifierDependency,
-			new HarmonyExportSpecifierDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyExportSpecifierDependency),
-				this.rootModule
-			)
-		);
-		innerDependencyTemplates.set(
-			HarmonyExportExpressionDependency,
-			new HarmonyExportExpressionDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyExportExpressionDependency),
-				this.rootModule
-			)
-		);
-		innerDependencyTemplates.set(
-			HarmonyExportImportedSpecifierDependency,
-			new HarmonyExportImportedSpecifierDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyExportImportedSpecifierDependency),
-				this.rootModule,
-				moduleToInfoMap
-			)
-		);
-		innerDependencyTemplates.set(
-			HarmonyCompatibilityDependency,
-			new HarmonyCompatibilityDependencyConcatenatedTemplate(
-				dependencyTemplates.get(HarmonyCompatibilityDependency),
-				this.rootModule,
-				moduleToInfoMap
-			)
-		);
-
-		// Must use full identifier in our cache here to ensure that the source
-		// is updated should our dependencies list change.
-		// TODO webpack 5 refactor
-		innerDependencyTemplates.set(
-			"hash",
-			innerDependencyTemplates.get("hash") + this.identifier()
-		);
-
-		// Generate source code and analyse scopes
-		// Prepare a ReplaceSource for the final source
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				const m = info.module;
-				const source = m.source(innerDependencyTemplates, runtimeTemplate);
-				const code = source.source();
-				let ast;
-				try {
-					ast = Parser.parse(code, {
-						sourceType: "module"
-					});
-				} catch (err) {
-					if (
-						err.loc &&
-						typeof err.loc === "object" &&
-						typeof err.loc.line === "number"
-					) {
-						const lineNumber = err.loc.line;
-						const lines = code.split("\n");
-						err.message +=
-							"\n| " +
-							lines
-								.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-								.join("\n| ");
-					}
-					throw err;
-				}
-				const scopeManager = eslintScope.analyze(ast, {
-					ecmaVersion: 6,
-					sourceType: "module",
-					optimistic: true,
-					ignoreEval: true,
-					impliedStrict: true
-				});
-				const globalScope = scopeManager.acquire(ast);
-				const moduleScope = globalScope.childScopes[0];
-				const resultSource = new ReplaceSource(source);
-				info.ast = ast;
-				info.internalSource = source;
-				info.source = resultSource;
-				info.globalScope = globalScope;
-				info.moduleScope = moduleScope;
-			}
-		}
-
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set([
-			"__WEBPACK_MODULE_DEFAULT_EXPORT__", // avoid using this internal name
-
-			"abstract",
-			"arguments",
-			"async",
-			"await",
-			"boolean",
-			"break",
-			"byte",
-			"case",
-			"catch",
-			"char",
-			"class",
-			"const",
-			"continue",
-			"debugger",
-			"default",
-			"delete",
-			"do",
-			"double",
-			"else",
-			"enum",
-			"eval",
-			"export",
-			"extends",
-			"false",
-			"final",
-			"finally",
-			"float",
-			"for",
-			"function",
-			"goto",
-			"if",
-			"implements",
-			"import",
-			"in",
-			"instanceof",
-			"int",
-			"interface",
-			"let",
-			"long",
-			"native",
-			"new",
-			"null",
-			"package",
-			"private",
-			"protected",
-			"public",
-			"return",
-			"short",
-			"static",
-			"super",
-			"switch",
-			"synchronized",
-			"this",
-			"throw",
-			"throws",
-			"transient",
-			"true",
-			"try",
-			"typeof",
-			"var",
-			"void",
-			"volatile",
-			"while",
-			"with",
-			"yield",
-
-			"module",
-			"__dirname",
-			"__filename",
-			"exports",
-
-			"Array",
-			"Date",
-			"eval",
-			"function",
-			"hasOwnProperty",
-			"Infinity",
-			"isFinite",
-			"isNaN",
-			"isPrototypeOf",
-			"length",
-			"Math",
-			"NaN",
-			"name",
-			"Number",
-			"Object",
-			"prototype",
-			"String",
-			"toString",
-			"undefined",
-			"valueOf",
-
-			"alert",
-			"all",
-			"anchor",
-			"anchors",
-			"area",
-			"assign",
-			"blur",
-			"button",
-			"checkbox",
-			"clearInterval",
-			"clearTimeout",
-			"clientInformation",
-			"close",
-			"closed",
-			"confirm",
-			"constructor",
-			"crypto",
-			"decodeURI",
-			"decodeURIComponent",
-			"defaultStatus",
-			"document",
-			"element",
-			"elements",
-			"embed",
-			"embeds",
-			"encodeURI",
-			"encodeURIComponent",
-			"escape",
-			"event",
-			"fileUpload",
-			"focus",
-			"form",
-			"forms",
-			"frame",
-			"innerHeight",
-			"innerWidth",
-			"layer",
-			"layers",
-			"link",
-			"location",
-			"mimeTypes",
-			"navigate",
-			"navigator",
-			"frames",
-			"frameRate",
-			"hidden",
-			"history",
-			"image",
-			"images",
-			"offscreenBuffering",
-			"open",
-			"opener",
-			"option",
-			"outerHeight",
-			"outerWidth",
-			"packages",
-			"pageXOffset",
-			"pageYOffset",
-			"parent",
-			"parseFloat",
-			"parseInt",
-			"password",
-			"pkcs11",
-			"plugin",
-			"prompt",
-			"propertyIsEnum",
-			"radio",
-			"reset",
-			"screenX",
-			"screenY",
-			"scroll",
-			"secure",
-			"select",
-			"self",
-			"setInterval",
-			"setTimeout",
-			"status",
-			"submit",
-			"taint",
-			"text",
-			"textarea",
-			"top",
-			"unescape",
-			"untaint",
-			"window",
-
-			"onblur",
-			"onclick",
-			"onerror",
-			"onfocus",
-			"onkeydown",
-			"onkeypress",
-			"onkeyup",
-			"onmouseover",
-			"onload",
-			"onmouseup",
-			"onmousedown",
-			"onsubmit"
-		]);
-
-		// Set of already checked scopes
-		const alreadyCheckedScopes = new Set();
-
-		// get all global names
-		for (const info of modulesWithInfo) {
-			const superClassExpressions = [];
-
-			// ignore symbols from moduleScope
-			if (info.moduleScope) {
-				alreadyCheckedScopes.add(info.moduleScope);
-
-				// The super class expression in class scopes behaves weird
-				// We store ranges of all super class expressions to make
-				// renaming to work correctly
-				for (const childScope of info.moduleScope.childScopes) {
-					if (childScope.type !== "class") continue;
-					if (!childScope.block.superClass) continue;
-					superClassExpressions.push({
-						range: childScope.block.superClass.range,
-						variables: childScope.variables
-					});
-				}
-			}
-
-			// add global symbols
-			if (info.globalScope) {
-				for (const reference of info.globalScope.through) {
-					const name = reference.identifier.name;
-					if (
-						/^__WEBPACK_MODULE_REFERENCE__\d+_([\da-f]+|ns)(_call)?(_strict)?__$/.test(
-							name
-						)
-					) {
-						for (const expr of superClassExpressions) {
-							if (
-								expr.range[0] <= reference.identifier.range[0] &&
-								expr.range[1] >= reference.identifier.range[1]
-							) {
-								for (const variable of expr.variables) {
-									allUsedNames.add(variable.name);
-								}
-							}
-						}
-						addScopeSymbols1(
-							reference.from,
-							allUsedNames,
-							alreadyCheckedScopes
-						);
-					} else {
-						allUsedNames.add(name);
-					}
-				}
-			}
-
-			// add exported globals
-			if (info.type === "concatenated") {
-				const variables = new Set();
-				for (const variable of info.moduleScope.variables) {
-					variables.add(variable.name);
-				}
-				for (const [, variable] of info.exportMap) {
-					if (!variables.has(variable)) {
-						info.globalExports.add(variable);
-					}
-				}
-			}
-		}
-
-		// generate names for symbols
-		for (const info of modulesWithInfo) {
-			switch (info.type) {
-				case "concatenated": {
-					const namespaceObjectName = this.findNewName(
-						"namespaceObject",
-						allUsedNames,
-						null,
-						info.module.readableIdentifier(requestShortener)
-					);
-					allUsedNames.add(namespaceObjectName);
-					info.internalNames.set(namespaceObjectName, namespaceObjectName);
-					info.exportMap.set(true, namespaceObjectName);
-					for (const variable of info.moduleScope.variables) {
-						const name = variable.name;
-						if (allUsedNames.has(name)) {
-							const references = getAllReferences(variable);
-							const symbolsInReferences = new Set();
-							const alreadyCheckedInnerScopes = new Set();
-							for (const ref of references) {
-								addScopeSymbols2(
-									ref.from,
-									symbolsInReferences,
-									alreadyCheckedInnerScopes,
-									alreadyCheckedScopes
-								);
-							}
-							const newName = this.findNewName(
-								name,
-								allUsedNames,
-								symbolsInReferences,
-								info.module.readableIdentifier(requestShortener)
-							);
-							allUsedNames.add(newName);
-							info.internalNames.set(name, newName);
-							const source = info.source;
-							const allIdentifiers = new Set(
-								references.map(r => r.identifier).concat(variable.identifiers)
-							);
-							for (const identifier of allIdentifiers) {
-								const r = identifier.range;
-								const path = getPathInAst(info.ast, identifier);
-								if (
-									path &&
-									path.length > 1 &&
-									path[1].type === "Property" &&
-									path[1].shorthand
-								) {
-									source.insert(r[1], `: ${newName}`);
-								} else {
-									source.replace(r[0], r[1] - 1, newName);
-								}
-							}
-						} else {
-							allUsedNames.add(name);
-							info.internalNames.set(name, name);
-						}
-					}
-					break;
-				}
-				case "external": {
-					const externalName = this.findNewName(
-						"",
-						allUsedNames,
-						null,
-						info.module.readableIdentifier(requestShortener)
-					);
-					allUsedNames.add(externalName);
-					info.name = externalName;
-					if (
-						info.module.buildMeta.exportsType === "named" ||
-						!info.module.buildMeta.exportsType
-					) {
-						const externalNameInterop = this.findNewName(
-							"namespaceObject",
-							allUsedNames,
-							null,
-							info.module.readableIdentifier(requestShortener)
-						);
-						allUsedNames.add(externalNameInterop);
-						info.interopNamespaceObjectName = externalNameInterop;
-					}
-					if (!info.module.buildMeta.exportsType) {
-						const externalNameInterop = this.findNewName(
-							"default",
-							allUsedNames,
-							null,
-							info.module.readableIdentifier(requestShortener)
-						);
-						allUsedNames.add(externalNameInterop);
-						info.interopDefaultAccessName = externalNameInterop;
-					}
-					break;
-				}
-			}
-		}
-
-		// Find and replace referenced to modules
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				for (const reference of info.globalScope.through) {
-					const name = reference.identifier.name;
-					const match = /^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_strict)?__$/.exec(
-						name
-					);
-					if (match) {
-						const referencedModule = modulesWithInfo[+match[1]];
-						let exportName;
-						if (match[2] === "ns") {
-							exportName = true;
-						} else {
-							const exportData = match[2];
-							exportName = Buffer.from(exportData, "hex").toString("utf-8");
-						}
-						const asCall = !!match[3];
-						const strictHarmonyModule = !!match[4];
-						const finalName = getFinalName(
-							referencedModule,
-							exportName,
-							moduleToInfoMap,
-							requestShortener,
-							asCall,
-							strictHarmonyModule
-						);
-						const r = reference.identifier.range;
-						const source = info.source;
-						source.replace(r[0], r[1] - 1, finalName);
-					}
-				}
-			}
-		}
-
-		const result = new ConcatSource();
-
-		// add harmony compatibility flag (must be first because of possible circular dependencies)
-		const usedExports = this.rootModule.usedExports;
-		if (usedExports === true) {
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument
-				})
-			);
-		}
-
-		// define required namespace objects (must be before evaluation modules)
-		for (const info of modulesWithInfo) {
-			if (info.namespaceObjectSource) {
-				result.add(info.namespaceObjectSource);
-			}
-		}
-
-		// evaluate modules in order
-		for (const info of modulesWithInfo) {
-			switch (info.type) {
-				case "concatenated":
-					result.add(
-						`\n// CONCATENATED MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					result.add(info.source);
-					break;
-				case "external":
-					result.add(
-						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					result.add(
-						`var ${info.name} = __webpack_require__(${JSON.stringify(
-							info.module.id
-						)});\n`
-					);
-					if (info.interopNamespaceObjectUsed) {
-						if (info.module.buildMeta.exportsType === "named") {
-							result.add(
-								`var ${
-									info.interopNamespaceObjectName
-								} = /*#__PURE__*/__webpack_require__.t(${info.name}, 2);\n`
-							);
-						} else if (!info.module.buildMeta.exportsType) {
-							result.add(
-								`var ${
-									info.interopNamespaceObjectName
-								} = /*#__PURE__*/__webpack_require__.t(${info.name});\n`
-							);
-						}
-					}
-					if (info.interopDefaultAccessUsed) {
-						result.add(
-							`var ${
-								info.interopDefaultAccessName
-							} = /*#__PURE__*/__webpack_require__.n(${info.name});\n`
-						);
-					}
-					break;
-				default:
-					throw new Error(`Unsupported concatenation entry type ${info.type}`);
-			}
-		}
-
-		return result;
-	}
-
-	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
-		let name = oldName;
-
-		if (name === "__WEBPACK_MODULE_DEFAULT_EXPORT__") name = "";
-
-		// Remove uncool stuff
-		extraInfo = extraInfo.replace(
-			/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
-			""
-		);
-
-		const splittedInfo = extraInfo.split("/");
-		while (splittedInfo.length) {
-			name = splittedInfo.pop() + (name ? "_" + name : "");
-			const nameIdent = Template.toIdentifier(name);
-			if (
-				!usedNamed1.has(nameIdent) &&
-				(!usedNamed2 || !usedNamed2.has(nameIdent))
-			)
-				return nameIdent;
-		}
-
-		let i = 0;
-		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		while (
-			usedNamed1.has(nameWithNumber) ||
-			(usedNamed2 && usedNamed2.has(nameWithNumber))
-		) {
-			i++;
-			nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		}
-		return nameWithNumber;
-	}
-
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @returns {void}
-	 */
-	updateHash(hash) {
-		for (const info of this._orderedConcatenationList) {
-			switch (info.type) {
-				case "concatenated":
-					info.module.updateHash(hash);
-					break;
-				case "external":
-					hash.update(`${info.module.id}`);
-					break;
-			}
-		}
-		super.updateHash(hash);
-	}
-}
-
-class HarmonyImportSpecifierDependencyConcatenatedTemplate {
-	constructor(originalTemplate, modulesMap) {
-		this.originalTemplate = originalTemplate;
-		this.modulesMap = modulesMap;
-	}
-
-	getHarmonyInitOrder(dep) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			return this.originalTemplate.getHarmonyInitOrder(dep);
-		}
-		return NaN;
-	}
-
-	harmonyInit(dep, source, runtimeTemplate, dependencyTemplates) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			this.originalTemplate.harmonyInit(
-				dep,
-				source,
-				runtimeTemplate,
-				dependencyTemplates
-			);
-			return;
-		}
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			this.originalTemplate.apply(dep, source, runtime, dependencyTemplates);
-			return;
-		}
-		let content;
-		const callFlag = dep.call ? "_call" : "";
-		const strictFlag = dep.originModule.buildMeta.strictHarmonyModule
-			? "_strict"
-			: "";
-		if (dep._id === null) {
-			content = `__WEBPACK_MODULE_REFERENCE__${info.index}_ns${strictFlag}__`;
-		} else if (dep.namespaceObjectAsContext) {
-			content = `__WEBPACK_MODULE_REFERENCE__${
-				info.index
-			}_ns${strictFlag}__[${JSON.stringify(dep._id)}]`;
-		} else {
-			const exportData = Buffer.from(dep._id, "utf-8").toString("hex");
-			content = `__WEBPACK_MODULE_REFERENCE__${
-				info.index
-			}_${exportData}${callFlag}${strictFlag}__`;
-		}
-		if (dep.shorthand) {
-			content = dep.name + ": " + content;
-		}
-		source.replace(dep.range[0], dep.range[1] - 1, content);
-	}
-}
-
-class HarmonyImportSideEffectDependencyConcatenatedTemplate {
-	constructor(originalTemplate, modulesMap) {
-		this.originalTemplate = originalTemplate;
-		this.modulesMap = modulesMap;
-	}
-
-	getHarmonyInitOrder(dep) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			return this.originalTemplate.getHarmonyInitOrder(dep);
-		}
-		return NaN;
-	}
-
-	harmonyInit(dep, source, runtime, dependencyTemplates) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			this.originalTemplate.harmonyInit(
-				dep,
-				source,
-				runtime,
-				dependencyTemplates
-			);
-			return;
-		}
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			this.originalTemplate.apply(dep, source, runtime, dependencyTemplates);
-			return;
-		}
-	}
-}
-
-class HarmonyExportSpecifierDependencyConcatenatedTemplate {
-	constructor(originalTemplate, rootModule) {
-		this.originalTemplate = originalTemplate;
-		this.rootModule = rootModule;
-	}
-
-	getHarmonyInitOrder(dep) {
-		if (dep.originModule === this.rootModule) {
-			return this.originalTemplate.getHarmonyInitOrder(dep);
-		}
-		return NaN;
-	}
-
-	harmonyInit(dep, source, runtime, dependencyTemplates) {
-		if (dep.originModule === this.rootModule) {
-			this.originalTemplate.harmonyInit(
-				dep,
-				source,
-				runtime,
-				dependencyTemplates
-			);
-			return;
-		}
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		if (dep.originModule === this.rootModule) {
-			this.originalTemplate.apply(dep, source, runtime, dependencyTemplates);
-		}
-	}
-}
-
-class HarmonyExportExpressionDependencyConcatenatedTemplate {
-	constructor(originalTemplate, rootModule) {
-		this.originalTemplate = originalTemplate;
-		this.rootModule = rootModule;
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		let content =
-			"/* harmony default export */ var __WEBPACK_MODULE_DEFAULT_EXPORT__ = ";
-		if (dep.originModule === this.rootModule) {
-			const used = dep.originModule.isUsed("default");
-			const exportsName = dep.originModule.exportsArgument;
-			if (used) content += `${exportsName}[${JSON.stringify(used)}] = `;
-		}
-
-		if (dep.range) {
-			source.replace(dep.rangeStatement[0], dep.range[0] - 1, content + "(");
-			source.replace(dep.range[1], dep.rangeStatement[1] - 1, ");");
-			return;
-		}
-
-		source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
-	}
-}
-
-class HarmonyExportImportedSpecifierDependencyConcatenatedTemplate {
-	constructor(originalTemplate, rootModule, modulesMap) {
-		this.originalTemplate = originalTemplate;
-		this.rootModule = rootModule;
-		this.modulesMap = modulesMap;
-	}
-
-	getExports(dep) {
-		const importModule = dep._module;
-		if (dep.id) {
-			// export { named } from "module"
-			return [
-				{
-					name: dep.name,
-					id: dep.id,
-					module: importModule
-				}
-			];
-		}
-		if (dep.name) {
-			// export * as abc from "module"
-			return [
-				{
-					name: dep.name,
-					id: true,
-					module: importModule
-				}
-			];
-		}
-		// export * from "module"
-		return importModule.buildMeta.providedExports
-			.filter(exp => exp !== "default" && !dep.activeExports.has(exp))
-			.map(exp => {
-				return {
-					name: exp,
-					id: exp,
-					module: importModule
-				};
-			});
-	}
-
-	getHarmonyInitOrder(dep) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			return this.originalTemplate.getHarmonyInitOrder(dep);
-		}
-		return NaN;
-	}
-
-	harmonyInit(dep, source, runtime, dependencyTemplates) {
-		const module = dep._module;
-		const info = this.modulesMap.get(module);
-		if (!info) {
-			this.originalTemplate.harmonyInit(
-				dep,
-				source,
-				runtime,
-				dependencyTemplates
-			);
-			return;
-		}
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		if (dep.originModule === this.rootModule) {
-			if (this.modulesMap.get(dep._module)) {
-				const exportDefs = this.getExports(dep);
-				for (const def of exportDefs) {
-					const info = this.modulesMap.get(def.module);
-					const used = dep.originModule.isUsed(def.name);
-					if (!used) {
-						source.insert(
-							-1,
-							`/* unused concated harmony import ${def.name} */\n`
-						);
-						continue;
-					}
-					let finalName;
-					const strictFlag = dep.originModule.buildMeta.strictHarmonyModule
-						? "_strict"
-						: "";
-					if (def.id === true) {
-						finalName = `__WEBPACK_MODULE_REFERENCE__${
-							info.index
-						}_ns${strictFlag}__`;
-					} else {
-						const exportData = Buffer.from(def.id, "utf-8").toString("hex");
-						finalName = `__WEBPACK_MODULE_REFERENCE__${
-							info.index
-						}_${exportData}${strictFlag}__`;
-					}
-					const exportsName = this.rootModule.exportsArgument;
-					const content =
-						`/* concated harmony reexport ${def.name} */` +
-						`__webpack_require__.d(${exportsName}, ` +
-						`${JSON.stringify(used)}, ` +
-						`function() { return ${finalName}; });\n`;
-					source.insert(-1, content);
-				}
-			} else {
-				this.originalTemplate.apply(dep, source, runtime, dependencyTemplates);
-			}
-		}
-	}
-}
-
-class HarmonyCompatibilityDependencyConcatenatedTemplate {
-	constructor(originalTemplate, rootModule, modulesMap) {
-		this.originalTemplate = originalTemplate;
-		this.rootModule = rootModule;
-		this.modulesMap = modulesMap;
-	}
-
-	apply(dep, source, runtime, dependencyTemplates) {
-		// do nothing
-	}
-}
-
-module.exports = ConcatenatedModule;
diff --git a/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js b/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js
deleted file mode 100644
index 5d05ec834..000000000
--- a/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const GraphHelpers = require("../GraphHelpers");
-
-class EnsureChunkConditionsPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EnsureChunkConditionsPlugin",
-			compilation => {
-				const handler = chunks => {
-					let changed = false;
-					for (const module of compilation.modules) {
-						if (!module.chunkCondition) continue;
-						const sourceChunks = new Set();
-						const chunkGroups = new Set();
-						for (const chunk of module.chunksIterable) {
-							if (!module.chunkCondition(chunk)) {
-								sourceChunks.add(chunk);
-								for (const group of chunk.groupsIterable) {
-									chunkGroups.add(group);
-								}
-							}
-						}
-						if (sourceChunks.size === 0) continue;
-						const targetChunks = new Set();
-						chunkGroupLoop: for (const chunkGroup of chunkGroups) {
-							// Can module be placed in a chunk of this group?
-							for (const chunk of chunkGroup.chunks) {
-								if (module.chunkCondition(chunk)) {
-									targetChunks.add(chunk);
-									continue chunkGroupLoop;
-								}
-							}
-							// We reached the entrypoint: fail
-							if (chunkGroup.isInitial()) {
-								throw new Error(
-									"Cannot fullfil chunk condition of " + module.identifier()
-								);
-							}
-							// Try placing in all parents
-							for (const group of chunkGroup.parentsIterable) {
-								chunkGroups.add(group);
-							}
-						}
-						for (const sourceChunk of sourceChunks) {
-							GraphHelpers.disconnectChunkAndModule(sourceChunk, module);
-						}
-						for (const targetChunk of targetChunks) {
-							GraphHelpers.connectChunkAndModule(targetChunk, module);
-						}
-					}
-					if (changed) return true;
-				};
-				compilation.hooks.optimizeChunksBasic.tap(
-					"EnsureChunkConditionsPlugin",
-					handler
-				);
-				compilation.hooks.optimizeExtractedChunksBasic.tap(
-					"EnsureChunkConditionsPlugin",
-					handler
-				);
-			}
-		);
-	}
-}
-module.exports = EnsureChunkConditionsPlugin;
diff --git a/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js b/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js
deleted file mode 100644
index 1890f0581..000000000
--- a/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class FlagIncludedChunksPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
-			compilation.hooks.optimizeChunkIds.tap(
-				"FlagIncludedChunksPlugin",
-				chunks => {
-					// prepare two bit integers for each module
-					// 2^31 is the max number represented as SMI in v8
-					// we want the bits distributed this way:
-					// the bit 2^31 is pretty rar and only one module should get it
-					// so it has a probability of 1 / modulesCount
-					// the first bit (2^0) is the easiest and every module could get it
-					// if it doesn't get a better bit
-					// from bit 2^n to 2^(n+1) there is a probability of p
-					// so 1 / modulesCount == p^31
-					// <=> p = sqrt31(1 / modulesCount)
-					// so we use a modulo of 1 / sqrt31(1 / modulesCount)
-					const moduleBits = new WeakMap();
-					const modulesCount = compilation.modules.length;
-
-					// precalculate the modulo values for each bit
-					const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
-					const modulos = Array.from(
-						{ length: 31 },
-						(x, i) => Math.pow(modulo, i) | 0
-					);
-
-					// iterate all modules to generate bit values
-					let i = 0;
-					for (const module of compilation.modules) {
-						let bit = 30;
-						while (i % modulos[bit] !== 0) {
-							bit--;
-						}
-						moduleBits.set(module, 1 << bit);
-						i++;
-					}
-
-					// interate all chunks to generate bitmaps
-					const chunkModulesHash = new WeakMap();
-					for (const chunk of chunks) {
-						let hash = 0;
-						for (const module of chunk.modulesIterable) {
-							hash |= moduleBits.get(module);
-						}
-						chunkModulesHash.set(chunk, hash);
-					}
-
-					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
-						const chunkAModulesCount = chunkA.getNumberOfModules();
-						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
-						for (const module of chunkA.modulesIterable) {
-							if (
-								bestModule === undefined ||
-								bestModule.getNumberOfChunks() > module.getNumberOfChunks()
-							)
-								bestModule = module;
-						}
-						loopB: for (const chunkB of bestModule.chunksIterable) {
-							// as we iterate the same iterables twice
-							// skip if we find ourselves
-							if (chunkA === chunkB) continue;
-
-							const chunkBModulesCount = chunkB.getNumberOfModules();
-
-							// ids for empty chunks are not included
-							if (chunkBModulesCount === 0) continue;
-
-							// instead of swapping A and B just bail
-							// as we loop twice the current A will be B and B then A
-							if (chunkAModulesCount > chunkBModulesCount) continue;
-
-							// is chunkA in chunkB?
-
-							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
-							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
-
-							// compare all modules
-							for (const m of chunkA.modulesIterable) {
-								if (!chunkB.containsModule(m)) continue loopB;
-							}
-							chunkB.ids.push(chunkA.id);
-						}
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = FlagIncludedChunksPlugin;
diff --git a/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js b/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js
deleted file mode 100644
index f38b942b1..000000000
--- a/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const validateOptions = require("schema-utils");
-const schema = require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json");
-
-class LimitChunkCountPlugin {
-	constructor(options) {
-		validateOptions(schema, options || {}, "Limit Chunk Count Plugin");
-		this.options = options || {};
-	}
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
-			compilation.hooks.optimizeChunksAdvanced.tap(
-				"LimitChunkCountPlugin",
-				chunks => {
-					const maxChunks = options.maxChunks;
-					if (!maxChunks) return;
-					if (maxChunks < 1) return;
-					if (chunks.length <= maxChunks) return;
-
-					const sortedExtendedPairCombinations = chunks
-						.reduce((combinations, a, idx) => {
-							// create combination pairs
-							for (let i = 0; i < idx; i++) {
-								const b = chunks[i];
-								combinations.push([b, a]);
-							}
-							return combinations;
-						}, [])
-						.map(pair => {
-							// extend combination pairs with size and integrated size
-							const a = pair[0].size(options);
-							const b = pair[1].size(options);
-							const ab = pair[0].integratedSize(pair[1], options);
-							return [a + b - ab, ab, pair[0], pair[1], a, b];
-						})
-						.filter(extendedPair => {
-							// filter pairs that do not have an integratedSize
-							// meaning they can NOT be integrated!
-							return extendedPair[1] !== false;
-						})
-						.sort((a, b) => {
-							// sadly javascript does an inplace sort here
-							// sort them by size
-							const diff = b[0] - a[0];
-							if (diff !== 0) return diff;
-							return a[1] - b[1];
-						});
-
-					const pair = sortedExtendedPairCombinations[0];
-
-					if (pair && pair[2].integrate(pair[3], "limit")) {
-						chunks.splice(chunks.indexOf(pair[3]), 1);
-						return true;
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = LimitChunkCountPlugin;
diff --git a/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js b/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js
deleted file mode 100644
index 1c3e23aa3..000000000
--- a/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class MergeDuplicateChunksPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"MergeDuplicateChunksPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunksBasic.tap(
-					"MergeDuplicateChunksPlugin",
-					chunks => {
-						// remember already tested chunks for performance
-						const notDuplicates = new Set();
-
-						// for each chunk
-						for (const chunk of chunks) {
-							// track a Set of all chunk that could be duplicates
-							let possibleDuplicates;
-							for (const module of chunk.modulesIterable) {
-								if (possibleDuplicates === undefined) {
-									// when possibleDuplicates is not yet set,
-									// create a new Set from chunks of the current module
-									// including only chunks with the same number of modules
-									for (const dup of module.chunksIterable) {
-										if (
-											dup !== chunk &&
-											chunk.getNumberOfModules() === dup.getNumberOfModules() &&
-											!notDuplicates.has(dup)
-										) {
-											// delay allocating the new Set until here, reduce memory pressure
-											if (possibleDuplicates === undefined) {
-												possibleDuplicates = new Set();
-											}
-											possibleDuplicates.add(dup);
-										}
-									}
-									// when no chunk is possible we can break here
-									if (possibleDuplicates === undefined) break;
-								} else {
-									// validate existing possible duplicates
-									for (const dup of possibleDuplicates) {
-										// remove possible duplicate when module is not contained
-										if (!dup.containsModule(module)) {
-											possibleDuplicates.delete(dup);
-										}
-									}
-									// when all chunks has been removed we can break here
-									if (possibleDuplicates.size === 0) break;
-								}
-							}
-
-							// when we found duplicates
-							if (
-								possibleDuplicates !== undefined &&
-								possibleDuplicates.size > 0
-							) {
-								for (const otherChunk of possibleDuplicates) {
-									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
-									// merge them
-									if (chunk.integrate(otherChunk, "duplicate")) {
-										chunks.splice(chunks.indexOf(otherChunk), 1);
-									}
-								}
-							}
-
-							// don't check already processed chunks twice
-							notDuplicates.add(chunk);
-						}
-					}
-				);
-			}
-		);
-	}
-}
-module.exports = MergeDuplicateChunksPlugin;
diff --git a/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js b/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js
deleted file mode 100644
index 0f3893910..000000000
--- a/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const validateOptions = require("schema-utils");
-const schema = require("../../schemas/plugins/optimize/MinChunkSizePlugin.json");
-
-class MinChunkSizePlugin {
-	constructor(options) {
-		validateOptions(schema, options, "Min Chunk Size Plugin");
-		this.options = options;
-	}
-
-	apply(compiler) {
-		const options = this.options;
-		const minChunkSize = options.minChunkSize;
-		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
-			compilation.hooks.optimizeChunksAdvanced.tap(
-				"MinChunkSizePlugin",
-				chunks => {
-					const equalOptions = {
-						chunkOverhead: 1,
-						entryChunkMultiplicator: 1
-					};
-
-					const sortedSizeFilteredExtendedPairCombinations = chunks
-						.reduce((combinations, a, idx) => {
-							// create combination pairs
-							for (let i = 0; i < idx; i++) {
-								const b = chunks[i];
-								combinations.push([b, a]);
-							}
-							return combinations;
-						}, [])
-						.filter(pair => {
-							// check if one of the chunks sizes is smaller than the minChunkSize
-							const p0SmallerThanMinChunkSize =
-								pair[0].size(equalOptions) < minChunkSize;
-							const p1SmallerThanMinChunkSize =
-								pair[1].size(equalOptions) < minChunkSize;
-							return p0SmallerThanMinChunkSize || p1SmallerThanMinChunkSize;
-						})
-						.map(pair => {
-							// extend combination pairs with size and integrated size
-							const a = pair[0].size(options);
-							const b = pair[1].size(options);
-							const ab = pair[0].integratedSize(pair[1], options);
-							return [a + b - ab, ab, pair[0], pair[1]];
-						})
-						.filter(pair => {
-							// filter pairs that do not have an integratedSize
-							// meaning they can NOT be integrated!
-							return pair[1] !== false;
-						})
-						.sort((a, b) => {
-							// sadly javascript does an inplace sort here
-							// sort by size
-							const diff = b[0] - a[0];
-							if (diff !== 0) return diff;
-							return a[1] - b[1];
-						});
-
-					if (sortedSizeFilteredExtendedPairCombinations.length === 0) return;
-
-					const pair = sortedSizeFilteredExtendedPairCombinations[0];
-
-					pair[2].integrate(pair[3], "min-size");
-					chunks.splice(chunks.indexOf(pair[3]), 1);
-					return true;
-				}
-			);
-		});
-	}
-}
-module.exports = MinChunkSizePlugin;
diff --git a/node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js b/node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js
deleted file mode 100644
index 15b7d796a..000000000
--- a/node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-const ModuleHotAcceptDependency = require("../dependencies/ModuleHotAcceptDependency");
-const ModuleHotDeclineDependency = require("../dependencies/ModuleHotDeclineDependency");
-const ConcatenatedModule = require("./ConcatenatedModule");
-const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
-const StackedSetMap = require("../util/StackedSetMap");
-
-const formatBailoutReason = msg => {
-	return "ModuleConcatenation bailout: " + msg;
-};
-
-class ModuleConcatenationPlugin {
-	constructor(options) {
-		if (typeof options !== "object") options = {};
-		this.options = options;
-	}
-
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ModuleConcatenationPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = (parser, parserOptions) => {
-					parser.hooks.call.for("eval").tap("ModuleConcatenationPlugin", () => {
-						// Because of variable renaming we can't use modules with eval.
-						parser.state.module.buildMeta.moduleConcatenationBailout = "eval()";
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ModuleConcatenationPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ModuleConcatenationPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ModuleConcatenationPlugin", handler);
-
-				const bailoutReasonMap = new Map();
-
-				const setBailoutReason = (module, reason) => {
-					bailoutReasonMap.set(module, reason);
-					module.optimizationBailout.push(
-						typeof reason === "function"
-							? rs => formatBailoutReason(reason(rs))
-							: formatBailoutReason(reason)
-					);
-				};
-
-				const getBailoutReason = (module, requestShortener) => {
-					const reason = bailoutReasonMap.get(module);
-					if (typeof reason === "function") return reason(requestShortener);
-					return reason;
-				};
-
-				compilation.hooks.optimizeChunkModules.tap(
-					"ModuleConcatenationPlugin",
-					(chunks, modules) => {
-						const relevantModules = [];
-						const possibleInners = new Set();
-						for (const module of modules) {
-							// Only harmony modules are valid for optimization
-							if (
-								!module.buildMeta ||
-								module.buildMeta.exportsType !== "namespace" ||
-								!module.dependencies.some(
-									d => d instanceof HarmonyCompatibilityDependency
-								)
-							) {
-								setBailoutReason(module, "Module is not an ECMAScript module");
-								continue;
-							}
-
-							// Some expressions are not compatible with module concatenation
-							// because they may produce unexpected results. The plugin bails out
-							// if some were detected upfront.
-							if (
-								module.buildMeta &&
-								module.buildMeta.moduleConcatenationBailout
-							) {
-								setBailoutReason(
-									module,
-									`Module uses ${module.buildMeta.moduleConcatenationBailout}`
-								);
-								continue;
-							}
-
-							// Exports must be known (and not dynamic)
-							if (!Array.isArray(module.buildMeta.providedExports)) {
-								setBailoutReason(module, "Module exports are unknown");
-								continue;
-							}
-
-							// Using dependency variables is not possible as this wraps the code in a function
-							if (module.variables.length > 0) {
-								setBailoutReason(
-									module,
-									`Module uses injected variables (${module.variables
-										.map(v => v.name)
-										.join(", ")})`
-								);
-								continue;
-							}
-
-							// Hot Module Replacement need it's own module to work correctly
-							if (
-								module.dependencies.some(
-									dep =>
-										dep instanceof ModuleHotAcceptDependency ||
-										dep instanceof ModuleHotDeclineDependency
-								)
-							) {
-								setBailoutReason(module, "Module uses Hot Module Replacement");
-								continue;
-							}
-
-							relevantModules.push(module);
-
-							// Module must not be the entry points
-							if (module.isEntryModule()) {
-								setBailoutReason(module, "Module is an entry point");
-								continue;
-							}
-
-							// Module must be in any chunk (we don't want to do useless work)
-							if (module.getNumberOfChunks() === 0) {
-								setBailoutReason(module, "Module is not in any chunk");
-								continue;
-							}
-
-							// Module must only be used by Harmony Imports
-							const nonHarmonyReasons = module.reasons.filter(
-								reason =>
-									!reason.dependency ||
-									!(reason.dependency instanceof HarmonyImportDependency)
-							);
-							if (nonHarmonyReasons.length > 0) {
-								const importingModules = new Set(
-									nonHarmonyReasons.map(r => r.module).filter(Boolean)
-								);
-								const importingExplanations = new Set(
-									nonHarmonyReasons.map(r => r.explanation).filter(Boolean)
-								);
-								const importingModuleTypes = new Map(
-									Array.from(importingModules).map(
-										m => /** @type {[string, Set]} */ ([
-											m,
-											new Set(
-												nonHarmonyReasons
-													.filter(r => r.module === m)
-													.map(r => r.dependency.type)
-													.sort()
-											)
-										])
-									)
-								);
-								setBailoutReason(module, requestShortener => {
-									const names = Array.from(importingModules)
-										.map(
-											m =>
-												`${m.readableIdentifier(
-													requestShortener
-												)} (referenced with ${Array.from(
-													importingModuleTypes.get(m)
-												).join(", ")})`
-										)
-										.sort();
-									const explanations = Array.from(importingExplanations).sort();
-									if (names.length > 0 && explanations.length === 0) {
-										return `Module is referenced from these modules with unsupported syntax: ${names.join(
-											", "
-										)}`;
-									} else if (names.length === 0 && explanations.length > 0) {
-										return `Module is referenced by: ${explanations.join(
-											", "
-										)}`;
-									} else if (names.length > 0 && explanations.length > 0) {
-										return `Module is referenced from these modules with unsupported syntax: ${names.join(
-											", "
-										)} and by: ${explanations.join(", ")}`;
-									} else {
-										return "Module is referenced in a unsupported way";
-									}
-								});
-								continue;
-							}
-
-							possibleInners.add(module);
-						}
-						// sort by depth
-						// modules with lower depth are more likely suited as roots
-						// this improves performance, because modules already selected as inner are skipped
-						relevantModules.sort((a, b) => {
-							return a.depth - b.depth;
-						});
-						const concatConfigurations = [];
-						const usedAsInner = new Set();
-						for (const currentRoot of relevantModules) {
-							// when used by another configuration as inner:
-							// the other configuration is better and we can skip this one
-							if (usedAsInner.has(currentRoot)) continue;
-
-							// create a configuration with the root
-							const currentConfiguration = new ConcatConfiguration(currentRoot);
-
-							// cache failures to add modules
-							const failureCache = new Map();
-
-							// try to add all imports
-							for (const imp of this._getImports(compilation, currentRoot)) {
-								const problem = this._tryToAdd(
-									compilation,
-									currentConfiguration,
-									imp,
-									possibleInners,
-									failureCache
-								);
-								if (problem) {
-									failureCache.set(imp, problem);
-									currentConfiguration.addWarning(imp, problem);
-								}
-							}
-							if (!currentConfiguration.isEmpty()) {
-								concatConfigurations.push(currentConfiguration);
-								for (const module of currentConfiguration.getModules()) {
-									if (module !== currentConfiguration.rootModule) {
-										usedAsInner.add(module);
-									}
-								}
-							}
-						}
-						// HACK: Sort configurations by length and start with the longest one
-						// to get the biggers groups possible. Used modules are marked with usedModules
-						// TODO: Allow to reuse existing configuration while trying to add dependencies.
-						// This would improve performance. O(n^2) -> O(n)
-						concatConfigurations.sort((a, b) => {
-							return b.modules.size - a.modules.size;
-						});
-						const usedModules = new Set();
-						for (const concatConfiguration of concatConfigurations) {
-							if (usedModules.has(concatConfiguration.rootModule)) continue;
-							const modules = concatConfiguration.getModules();
-							const rootModule = concatConfiguration.rootModule;
-							const newModule = new ConcatenatedModule(
-								rootModule,
-								Array.from(modules),
-								ConcatenatedModule.createConcatenationList(
-									rootModule,
-									modules,
-									compilation
-								)
-							);
-							for (const warning of concatConfiguration.getWarningsSorted()) {
-								newModule.optimizationBailout.push(requestShortener => {
-									const reason = getBailoutReason(warning[0], requestShortener);
-									const reasonWithPrefix = reason ? ` (<- ${reason})` : "";
-									if (warning[0] === warning[1]) {
-										return formatBailoutReason(
-											`Cannot concat with ${warning[0].readableIdentifier(
-												requestShortener
-											)}${reasonWithPrefix}`
-										);
-									} else {
-										return formatBailoutReason(
-											`Cannot concat with ${warning[0].readableIdentifier(
-												requestShortener
-											)} because of ${warning[1].readableIdentifier(
-												requestShortener
-											)}${reasonWithPrefix}`
-										);
-									}
-								});
-							}
-							const chunks = concatConfiguration.rootModule.getChunks();
-							for (const m of modules) {
-								usedModules.add(m);
-								for (const chunk of chunks) {
-									chunk.removeModule(m);
-								}
-							}
-							for (const chunk of chunks) {
-								chunk.addModule(newModule);
-								newModule.addChunk(chunk);
-								if (chunk.entryModule === concatConfiguration.rootModule) {
-									chunk.entryModule = newModule;
-								}
-							}
-							compilation.modules.push(newModule);
-							for (const reason of newModule.reasons) {
-								if (reason.dependency.module === concatConfiguration.rootModule)
-									reason.dependency.module = newModule;
-								if (
-									reason.dependency.redirectedModule ===
-									concatConfiguration.rootModule
-								)
-									reason.dependency.redirectedModule = newModule;
-							}
-							// TODO: remove when LTS node version contains fixed v8 version
-							// @see https://github.com/webpack/webpack/pull/6613
-							// Turbofan does not correctly inline for-of loops with polymorphic input arrays.
-							// Work around issue by using a standard for loop and assigning dep.module.reasons
-							for (let i = 0; i < newModule.dependencies.length; i++) {
-								let dep = newModule.dependencies[i];
-								if (dep.module) {
-									let reasons = dep.module.reasons;
-									for (let j = 0; j < reasons.length; j++) {
-										let reason = reasons[j];
-										if (reason.dependency === dep) {
-											reason.module = newModule;
-										}
-									}
-								}
-							}
-						}
-						compilation.modules = compilation.modules.filter(
-							m => !usedModules.has(m)
-						);
-					}
-				);
-			}
-		);
-	}
-
-	_getImports(compilation, module) {
-		return new Set(
-			module.dependencies
-
-				// Get reference info only for harmony Dependencies
-				.map(dep => {
-					if (!(dep instanceof HarmonyImportDependency)) return null;
-					if (!compilation) return dep.getReference();
-					return compilation.getDependencyReference(module, dep);
-				})
-
-				// Reference is valid and has a module
-				// Dependencies are simple enough to concat them
-				.filter(
-					ref =>
-						ref &&
-						ref.module &&
-						(Array.isArray(ref.importedNames) ||
-							Array.isArray(ref.module.buildMeta.providedExports))
-				)
-
-				// Take the imported module
-				.map(ref => ref.module)
-		);
-	}
-
-	_tryToAdd(compilation, config, module, possibleModules, failureCache) {
-		const cacheEntry = failureCache.get(module);
-		if (cacheEntry) {
-			return cacheEntry;
-		}
-
-		// Already added?
-		if (config.has(module)) {
-			return null;
-		}
-
-		// Not possible to add?
-		if (!possibleModules.has(module)) {
-			failureCache.set(module, module); // cache failures for performance
-			return module;
-		}
-
-		// module must be in the same chunks
-		if (!config.rootModule.hasEqualsChunks(module)) {
-			failureCache.set(module, module); // cache failures for performance
-			return module;
-		}
-
-		// Clone config to make experimental changes
-		const testConfig = config.clone();
-
-		// Add the module
-		testConfig.add(module);
-
-		// Every module which depends on the added module must be in the configuration too.
-		for (const reason of module.reasons) {
-			// Modules that are not used can be ignored
-			if (
-				reason.module.factoryMeta.sideEffectFree &&
-				reason.module.used === false
-			)
-				continue;
-
-			const problem = this._tryToAdd(
-				compilation,
-				testConfig,
-				reason.module,
-				possibleModules,
-				failureCache
-			);
-			if (problem) {
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
-			}
-		}
-
-		// Commit experimental changes
-		config.set(testConfig);
-
-		// Eagerly try to add imports too if possible
-		for (const imp of this._getImports(compilation, module)) {
-			const problem = this._tryToAdd(
-				compilation,
-				config,
-				imp,
-				possibleModules,
-				failureCache
-			);
-			if (problem) {
-				config.addWarning(imp, problem);
-			}
-		}
-		return null;
-	}
-}
-
-class ConcatConfiguration {
-	constructor(rootModule, cloneFrom) {
-		this.rootModule = rootModule;
-		if (cloneFrom) {
-			this.modules = cloneFrom.modules.createChild(5);
-			this.warnings = cloneFrom.warnings.createChild(5);
-		} else {
-			this.modules = new StackedSetMap();
-			this.modules.add(rootModule);
-			this.warnings = new StackedSetMap();
-		}
-	}
-
-	add(module) {
-		this.modules.add(module);
-	}
-
-	has(module) {
-		return this.modules.has(module);
-	}
-
-	isEmpty() {
-		return this.modules.size === 1;
-	}
-
-	addWarning(module, problem) {
-		this.warnings.set(module, problem);
-	}
-
-	getWarningsSorted() {
-		return new Map(
-			this.warnings.asPairArray().sort((a, b) => {
-				const ai = a[0].identifier();
-				const bi = b[0].identifier();
-				if (ai < bi) return -1;
-				if (ai > bi) return 1;
-				return 0;
-			})
-		);
-	}
-
-	getModules() {
-		return this.modules.asSet();
-	}
-
-	clone() {
-		return new ConcatConfiguration(this.rootModule, this);
-	}
-
-	set(config) {
-		this.rootModule = config.rootModule;
-		this.modules = config.modules;
-		this.warnings = config.warnings;
-	}
-}
-
-module.exports = ModuleConcatenationPlugin;
diff --git a/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js b/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js
deleted file mode 100644
index c73ec8e57..000000000
--- a/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-// TODO webpack 5 remove this plugin
-// It has been splitted into separate plugins for modules and chunks
-class OccurrenceOrderPlugin {
-	constructor(preferEntry) {
-		if (preferEntry !== undefined && typeof preferEntry !== "boolean") {
-			throw new Error(
-				"Argument should be a boolean.\nFor more info on this plugin, see https://webpack.js.org/plugins/"
-			);
-		}
-		this.preferEntry = preferEntry;
-	}
-	apply(compiler) {
-		const preferEntry = this.preferEntry;
-		compiler.hooks.compilation.tap("OccurrenceOrderPlugin", compilation => {
-			compilation.hooks.optimizeModuleOrder.tap(
-				"OccurrenceOrderPlugin",
-				modules => {
-					const occursInInitialChunksMap = new Map();
-					const occursInAllChunksMap = new Map();
-
-					const initialChunkChunkMap = new Map();
-					const entryCountMap = new Map();
-					for (const m of modules) {
-						let initial = 0;
-						let entry = 0;
-						for (const c of m.chunksIterable) {
-							if (c.canBeInitial()) initial++;
-							if (c.entryModule === m) entry++;
-						}
-						initialChunkChunkMap.set(m, initial);
-						entryCountMap.set(m, entry);
-					}
-
-					const countOccursInEntry = (sum, r) => {
-						if (!r.module) {
-							return sum;
-						}
-						return sum + initialChunkChunkMap.get(r.module);
-					};
-					const countOccurs = (sum, r) => {
-						if (!r.module) {
-							return sum;
-						}
-						let factor = 1;
-						if (typeof r.dependency.getNumberOfIdOccurrences === "function") {
-							factor = r.dependency.getNumberOfIdOccurrences();
-						}
-						if (factor === 0) {
-							return sum;
-						}
-						return sum + factor * r.module.getNumberOfChunks();
-					};
-
-					if (preferEntry) {
-						for (const m of modules) {
-							const result =
-								m.reasons.reduce(countOccursInEntry, 0) +
-								initialChunkChunkMap.get(m) +
-								entryCountMap.get(m);
-							occursInInitialChunksMap.set(m, result);
-						}
-					}
-
-					const originalOrder = new Map();
-					let i = 0;
-					for (const m of modules) {
-						const result =
-							m.reasons.reduce(countOccurs, 0) +
-							m.getNumberOfChunks() +
-							entryCountMap.get(m);
-						occursInAllChunksMap.set(m, result);
-						originalOrder.set(m, i++);
-					}
-
-					modules.sort((a, b) => {
-						if (preferEntry) {
-							const aEntryOccurs = occursInInitialChunksMap.get(a);
-							const bEntryOccurs = occursInInitialChunksMap.get(b);
-							if (aEntryOccurs > bEntryOccurs) return -1;
-							if (aEntryOccurs < bEntryOccurs) return 1;
-						}
-						const aOccurs = occursInAllChunksMap.get(a);
-						const bOccurs = occursInAllChunksMap.get(b);
-						if (aOccurs > bOccurs) return -1;
-						if (aOccurs < bOccurs) return 1;
-						const orgA = originalOrder.get(a);
-						const orgB = originalOrder.get(b);
-						return orgA - orgB;
-					});
-				}
-			);
-			compilation.hooks.optimizeChunkOrder.tap(
-				"OccurrenceOrderPlugin",
-				chunks => {
-					const occursInInitialChunksMap = new Map();
-					const originalOrder = new Map();
-
-					let i = 0;
-					for (const c of chunks) {
-						let occurs = 0;
-						for (const chunkGroup of c.groupsIterable) {
-							for (const parent of chunkGroup.parentsIterable) {
-								if (parent.isInitial()) occurs++;
-							}
-						}
-						occursInInitialChunksMap.set(c, occurs);
-						originalOrder.set(c, i++);
-					}
-
-					chunks.sort((a, b) => {
-						const aEntryOccurs = occursInInitialChunksMap.get(a);
-						const bEntryOccurs = occursInInitialChunksMap.get(b);
-						if (aEntryOccurs > bEntryOccurs) return -1;
-						if (aEntryOccurs < bEntryOccurs) return 1;
-						const aOccurs = a.getNumberOfGroups();
-						const bOccurs = b.getNumberOfGroups();
-						if (aOccurs > bOccurs) return -1;
-						if (aOccurs < bOccurs) return 1;
-						const orgA = originalOrder.get(a);
-						const orgB = originalOrder.get(b);
-						return orgA - orgB;
-					});
-				}
-			);
-		});
-	}
-}
-
-module.exports = OccurrenceOrderPlugin;
diff --git a/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js b/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js
deleted file mode 100644
index 42ba24a15..000000000
--- a/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class RemoveEmptyChunksPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
-			const handler = chunks => {
-				for (let i = chunks.length - 1; i >= 0; i--) {
-					const chunk = chunks[i];
-					if (
-						chunk.isEmpty() &&
-						!chunk.hasRuntime() &&
-						!chunk.hasEntryModule()
-					) {
-						chunk.remove("empty");
-						chunks.splice(i, 1);
-					}
-				}
-			};
-			compilation.hooks.optimizeChunksBasic.tap(
-				"RemoveEmptyChunksPlugin",
-				handler
-			);
-			compilation.hooks.optimizeChunksAdvanced.tap(
-				"RemoveEmptyChunksPlugin",
-				handler
-			);
-			compilation.hooks.optimizeExtractedChunksBasic.tap(
-				"RemoveEmptyChunksPlugin",
-				handler
-			);
-			compilation.hooks.optimizeExtractedChunksAdvanced.tap(
-				"RemoveEmptyChunksPlugin",
-				handler
-			);
-		});
-	}
-}
-module.exports = RemoveEmptyChunksPlugin;
diff --git a/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js b/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js
deleted file mode 100644
index 7fff59207..000000000
--- a/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Queue = require("../util/Queue");
-const { intersect } = require("../util/SetHelpers");
-
-const getParentChunksWithModule = (currentChunk, module) => {
-	const chunks = [];
-	const stack = new Set(currentChunk.parentsIterable);
-
-	for (const chunk of stack) {
-		if (chunk.containsModule(module)) {
-			chunks.push(chunk);
-		} else {
-			for (const parent of chunk.parentsIterable) {
-				stack.add(parent);
-			}
-		}
-	}
-
-	return chunks;
-};
-
-class RemoveParentModulesPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
-			const handler = (chunks, chunkGroups) => {
-				const queue = new Queue();
-				const availableModulesMap = new WeakMap();
-
-				for (const chunkGroup of compilation.entrypoints.values()) {
-					// initialize available modules for chunks without parents
-					availableModulesMap.set(chunkGroup, new Set());
-					for (const child of chunkGroup.childrenIterable) {
-						queue.enqueue(child);
-					}
-				}
-
-				while (queue.length > 0) {
-					const chunkGroup = queue.dequeue();
-					let availableModules = availableModulesMap.get(chunkGroup);
-					let changed = false;
-					for (const parent of chunkGroup.parentsIterable) {
-						const availableModulesInParent = availableModulesMap.get(parent);
-						if (availableModulesInParent !== undefined) {
-							// If we know the available modules in parent: process these
-							if (availableModules === undefined) {
-								// if we have not own info yet: create new entry
-								availableModules = new Set(availableModulesInParent);
-								for (const chunk of parent.chunks) {
-									for (const m of chunk.modulesIterable) {
-										availableModules.add(m);
-									}
-								}
-								availableModulesMap.set(chunkGroup, availableModules);
-								changed = true;
-							} else {
-								for (const m of availableModules) {
-									if (
-										!parent.containsModule(m) &&
-										!availableModulesInParent.has(m)
-									) {
-										availableModules.delete(m);
-										changed = true;
-									}
-								}
-							}
-						}
-					}
-					if (changed) {
-						// if something changed: enqueue our children
-						for (const child of chunkGroup.childrenIterable) {
-							queue.enqueue(child);
-						}
-					}
-				}
-
-				// now we have available modules for every chunk
-				for (const chunk of chunks) {
-					const availableModulesSets = Array.from(
-						chunk.groupsIterable,
-						chunkGroup => availableModulesMap.get(chunkGroup)
-					);
-					if (availableModulesSets.some(s => s === undefined)) continue; // No info about this chunk group
-					const availableModules =
-						availableModulesSets.length === 1
-							? availableModulesSets[0]
-							: intersect(availableModulesSets);
-					const numberOfModules = chunk.getNumberOfModules();
-					const toRemove = new Set();
-					if (numberOfModules < availableModules.size) {
-						for (const m of chunk.modulesIterable) {
-							if (availableModules.has(m)) {
-								toRemove.add(m);
-							}
-						}
-					} else {
-						for (const m of availableModules) {
-							if (chunk.containsModule(m)) {
-								toRemove.add(m);
-							}
-						}
-					}
-					for (const module of toRemove) {
-						module.rewriteChunkInReasons(
-							chunk,
-							getParentChunksWithModule(chunk, module)
-						);
-						chunk.removeModule(module);
-					}
-				}
-			};
-			compilation.hooks.optimizeChunksBasic.tap(
-				"RemoveParentModulesPlugin",
-				handler
-			);
-			compilation.hooks.optimizeExtractedChunksBasic.tap(
-				"RemoveParentModulesPlugin",
-				handler
-			);
-		});
-	}
-}
-module.exports = RemoveParentModulesPlugin;